@glimmer/interfaces

  • Version 0.80.0
  • Published
  • 74.5 kB
  • 1 dependency
  • MIT license

Install

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

Overview

Overview not available.

Index

Variables

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CAPABILITIES

const CAPABILITIES: Symbol;

    variable CAPTURED_ARGS

    const CAPTURED_ARGS: Symbol;

      variable CURSOR_STACK

      const CURSOR_STACK: Symbol;

        variable TransactionSymbol

        const TransactionSymbol: Symbol;

          Interfaces

          interface ArgsOptions

          interface ArgsOptions extends SimpleArgsOptions {}

            property blocks

            blocks: NamedBlocks;

              property named

              named: WireFormat.Core.Hash;

                interface Arguments

                interface Arguments {}

                  property named

                  named: Record<string, unknown>;

                    property positional

                    positional: readonly unknown[];

                      interface AttributeCursor

                      interface AttributeCursor {}

                        property element

                        element: SimpleElement;

                          property name

                          name: string;

                            property namespace

                            namespace: Option<AttrNamespace>;

                              interface AttributeOperation

                              interface AttributeOperation {}

                                property attribute

                                attribute: AttributeCursor;

                                  method set

                                  set: (dom: ElementBuilder, value: unknown, env: Environment) => void;

                                    method update

                                    update: (value: unknown, env: Environment) => void;

                                      interface BlockArguments

                                      interface BlockArguments {}

                                        property length

                                        length: number;

                                          property names

                                          names: readonly string[];

                                            method capture

                                            capture: () => CapturedBlockArguments;

                                              method get

                                              get: (name: string) => ScopeBlock;

                                                method has

                                                has: (name: string) => boolean;

                                                  interface BlockOperand

                                                  interface BlockOperand {}

                                                    property type

                                                    type: HighLevelOperand.Block;

                                                      property value

                                                      value: WireFormat.SerializedInlineBlock | WireFormat.SerializedBlock;

                                                        interface BlockSymbolTable

                                                        interface BlockSymbolTable {}

                                                          property parameters

                                                          parameters: number[];

                                                            interface BlockWithContext

                                                            interface BlockWithContext {}

                                                              property block

                                                              readonly block: SerializedInlineBlock;

                                                                property containingLayout

                                                                readonly containingLayout: LayoutWithContext;

                                                                  interface Bounds

                                                                  interface Bounds {}

                                                                    method firstNode

                                                                    firstNode: () => any;

                                                                      method lastNode

                                                                      lastNode: () => any;

                                                                        method parentElement

                                                                        parentElement: () => any;

                                                                          interface Capabilities

                                                                          interface Capabilities {}

                                                                            property [CAPABILITIES]

                                                                            [CAPABILITIES]: true;

                                                                              interface CapturedArguments

                                                                              interface CapturedArguments {}

                                                                                property [CAPTURED_ARGS]

                                                                                [CAPTURED_ARGS]: true;

                                                                                  property named

                                                                                  named: CapturedNamedArguments;

                                                                                    property positional

                                                                                    positional: CapturedPositionalArguments;

                                                                                      interface CapturedBlockArguments

                                                                                      interface CapturedBlockArguments {}

                                                                                        property length

                                                                                        length: number;

                                                                                          property names

                                                                                          names: readonly string[];

                                                                                            method get

                                                                                            get: (name: string) => ScopeBlock;

                                                                                              method has

                                                                                              has: (name: string) => boolean;

                                                                                                interface CapturedNamedArguments

                                                                                                interface CapturedNamedArguments {}

                                                                                                  property [CAPTURED_ARGS]

                                                                                                  [CAPTURED_ARGS]: true;

                                                                                                    index signature

                                                                                                    [key: string]: Reference;

                                                                                                      interface CapturedPositionalArguments

                                                                                                      interface CapturedPositionalArguments extends Array<Reference> {}

                                                                                                        property [CAPTURED_ARGS]

                                                                                                        [CAPTURED_ARGS]: true;

                                                                                                          interface CapturedRenderNode

                                                                                                          interface CapturedRenderNode {}

                                                                                                            property args

                                                                                                            args: Arguments;

                                                                                                              property bounds

                                                                                                              bounds: null | {
                                                                                                              parentElement: SimpleElement;
                                                                                                              firstNode: SimpleNode;
                                                                                                              lastNode: SimpleNode;
                                                                                                              };

                                                                                                                property children

                                                                                                                children: CapturedRenderNode[];

                                                                                                                  property id

                                                                                                                  id: string;

                                                                                                                    property instance

                                                                                                                    instance: unknown;

                                                                                                                      property name

                                                                                                                      name: string;

                                                                                                                        property template

                                                                                                                        template: string | null;

                                                                                                                          property type

                                                                                                                          type: RenderNodeType;

                                                                                                                            interface CompilableProgram

                                                                                                                            interface CompilableProgram extends CompilableTemplate<ProgramSymbolTable> {}

                                                                                                                              property moduleName

                                                                                                                              moduleName: string;

                                                                                                                                interface CompilableTemplate

                                                                                                                                interface CompilableTemplate<S extends SymbolTable = SymbolTable> {}

                                                                                                                                  property symbolTable

                                                                                                                                  symbolTable: S;

                                                                                                                                    method compile

                                                                                                                                    compile: (context: CompileTimeCompilationContext) => HandleResult;

                                                                                                                                      interface CompilerArtifacts

                                                                                                                                      interface CompilerArtifacts {}

                                                                                                                                        property constants

                                                                                                                                        constants: ConstantPool;

                                                                                                                                          property heap

                                                                                                                                          heap: SerializedHeap;

                                                                                                                                            interface CompileTimeArtifacts

                                                                                                                                            interface CompileTimeArtifacts {}

                                                                                                                                              property constants

                                                                                                                                              constants: CompileTimeConstants & ResolutionTimeConstants;

                                                                                                                                                property heap

                                                                                                                                                heap: CompileTimeHeap;

                                                                                                                                                  interface CompileTimeCompilationContext

                                                                                                                                                  interface CompileTimeCompilationContext {}

                                                                                                                                                    property constants

                                                                                                                                                    readonly constants: CompileTimeConstants & ResolutionTimeConstants;

                                                                                                                                                      property heap

                                                                                                                                                      readonly heap: CompileTimeHeap;

                                                                                                                                                        property resolver

                                                                                                                                                        readonly resolver: CompileTimeResolver;

                                                                                                                                                          property stdlib

                                                                                                                                                          readonly stdlib: STDLib;

                                                                                                                                                            interface CompileTimeComponent

                                                                                                                                                            interface CompileTimeComponent {}

                                                                                                                                                              property capabilities

                                                                                                                                                              capabilities: InternalComponentCapability;

                                                                                                                                                                property compilable

                                                                                                                                                                compilable: Option<CompilableProgram>;

                                                                                                                                                                  property handle

                                                                                                                                                                  handle: number;

                                                                                                                                                                    interface CompileTimeConstants

                                                                                                                                                                    interface CompileTimeConstants {}
                                                                                                                                                                    • Constants are interned values that are referenced as numbers in the program. The constant pool is a part of the program, and is always transmitted together with the program.

                                                                                                                                                                    method array

                                                                                                                                                                    array: (values: unknown[] | readonly unknown[]) => number;

                                                                                                                                                                      method toPool

                                                                                                                                                                      toPool: () => ConstantPool;

                                                                                                                                                                        method value

                                                                                                                                                                        value: (value: unknown) => number;

                                                                                                                                                                          interface CompileTimeHeap

                                                                                                                                                                          interface CompileTimeHeap extends OpcodeHeap {}

                                                                                                                                                                            property offset

                                                                                                                                                                            offset: number;

                                                                                                                                                                              method capture

                                                                                                                                                                              capture: (offset?: number) => SerializedHeap;

                                                                                                                                                                                method finishMalloc

                                                                                                                                                                                finishMalloc: (handle: number, scopeSize: number) => void;

                                                                                                                                                                                  method getaddr

                                                                                                                                                                                  getaddr: (handle: number) => number;

                                                                                                                                                                                    method getbyaddr

                                                                                                                                                                                    getbyaddr: (address: number) => number;

                                                                                                                                                                                      method malloc

                                                                                                                                                                                      malloc: () => number;

                                                                                                                                                                                        method push

                                                                                                                                                                                        push: (name: Op, op1?: number, op2?: number, op3?: number) => void;

                                                                                                                                                                                          method setbyaddr

                                                                                                                                                                                          setbyaddr: (address: number, value: number) => void;

                                                                                                                                                                                            method sizeof

                                                                                                                                                                                            sizeof: (handle: number) => number;

                                                                                                                                                                                              interface CompileTimeResolver

                                                                                                                                                                                              interface CompileTimeResolver<O extends Owner = Owner> {}

                                                                                                                                                                                                method lookupBuiltInHelper

                                                                                                                                                                                                lookupBuiltInHelper: (name: string) => Option<HelperDefinitionState>;

                                                                                                                                                                                                  method lookupBuiltInModifier

                                                                                                                                                                                                  lookupBuiltInModifier: (name: string) => Option<ModifierDefinitionState>;

                                                                                                                                                                                                    method lookupComponent

                                                                                                                                                                                                    lookupComponent: (name: string, owner: O) => Option<ResolvedComponentDefinition>;

                                                                                                                                                                                                      method lookupHelper

                                                                                                                                                                                                      lookupHelper: (name: string, owner: O) => Option<HelperDefinitionState>;

                                                                                                                                                                                                        method lookupModifier

                                                                                                                                                                                                        lookupModifier: (name: string, owner: O) => Option<ModifierDefinitionState>;

                                                                                                                                                                                                          method lookupPartial

                                                                                                                                                                                                          lookupPartial: (name: string, owner: O) => Option<PartialDefinition>;

                                                                                                                                                                                                            interface ComponentCapabilities

                                                                                                                                                                                                            interface ComponentCapabilities extends Capabilities {}

                                                                                                                                                                                                              property asyncLifeCycleCallbacks

                                                                                                                                                                                                              asyncLifeCycleCallbacks: boolean;

                                                                                                                                                                                                                property destructor

                                                                                                                                                                                                                destructor: boolean;

                                                                                                                                                                                                                  property updateHook

                                                                                                                                                                                                                  updateHook: boolean;

                                                                                                                                                                                                                    interface ComponentCapabilitiesVersions

                                                                                                                                                                                                                    interface ComponentCapabilitiesVersions {}

                                                                                                                                                                                                                      property '3.13'

                                                                                                                                                                                                                      '3.13': {
                                                                                                                                                                                                                      asyncLifecycleCallbacks?: boolean;
                                                                                                                                                                                                                      destructor?: boolean;
                                                                                                                                                                                                                      updateHook?: boolean;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        property '3.4'

                                                                                                                                                                                                                        '3.4': {
                                                                                                                                                                                                                        asyncLifecycleCallbacks?: boolean;
                                                                                                                                                                                                                        destructor?: boolean;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          interface ComponentDefinition

                                                                                                                                                                                                                          interface ComponentDefinition<
                                                                                                                                                                                                                          D extends ComponentDefinitionState = ComponentDefinitionState,
                                                                                                                                                                                                                          I = ComponentInstanceState,
                                                                                                                                                                                                                          M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                            property capabilities

                                                                                                                                                                                                                            capabilities: InternalComponentCapability;

                                                                                                                                                                                                                              property compilable

                                                                                                                                                                                                                              compilable: CompilableProgram | null;

                                                                                                                                                                                                                                property handle

                                                                                                                                                                                                                                handle: number;

                                                                                                                                                                                                                                  property manager

                                                                                                                                                                                                                                  manager: M;

                                                                                                                                                                                                                                    property resolvedName

                                                                                                                                                                                                                                    resolvedName: string | null;

                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                      state: D;

                                                                                                                                                                                                                                        interface ComponentInstance

                                                                                                                                                                                                                                        interface ComponentInstance<
                                                                                                                                                                                                                                        D extends ComponentDefinitionState = ComponentDefinitionState,
                                                                                                                                                                                                                                        I = ComponentInstanceState,
                                                                                                                                                                                                                                        M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                          property capabilities

                                                                                                                                                                                                                                          capabilities: InternalComponentCapability;

                                                                                                                                                                                                                                            property definition

                                                                                                                                                                                                                                            definition: ComponentDefinition<D, I>;

                                                                                                                                                                                                                                              property handle

                                                                                                                                                                                                                                              handle: number;

                                                                                                                                                                                                                                                property lookup

                                                                                                                                                                                                                                                lookup: Record<string, ScopeSlot> | null;

                                                                                                                                                                                                                                                  property manager

                                                                                                                                                                                                                                                  manager: M;

                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                    state: I;

                                                                                                                                                                                                                                                      property table

                                                                                                                                                                                                                                                      table: ProgramSymbolTable;

                                                                                                                                                                                                                                                        interface ComponentManager

                                                                                                                                                                                                                                                        interface ComponentManager<ComponentStateBucket> {}

                                                                                                                                                                                                                                                          property capabilities

                                                                                                                                                                                                                                                          capabilities: ComponentCapabilities;

                                                                                                                                                                                                                                                            method createComponent

                                                                                                                                                                                                                                                            createComponent: (factory: object, args: Arguments) => ComponentStateBucket;

                                                                                                                                                                                                                                                              method getContext

                                                                                                                                                                                                                                                              getContext: (instance: ComponentStateBucket) => unknown;

                                                                                                                                                                                                                                                                interface ComponentManagerWithAsyncLifeCycleCallbacks

                                                                                                                                                                                                                                                                interface ComponentManagerWithAsyncLifeCycleCallbacks<ComponentStateBucket>
                                                                                                                                                                                                                                                                extends ComponentManager<ComponentStateBucket> {}

                                                                                                                                                                                                                                                                  method didCreateComponent

                                                                                                                                                                                                                                                                  didCreateComponent: (instance: ComponentStateBucket) => void;

                                                                                                                                                                                                                                                                    interface ComponentManagerWithAsyncUpdateHook

                                                                                                                                                                                                                                                                    interface ComponentManagerWithAsyncUpdateHook<ComponentStateBucket>
                                                                                                                                                                                                                                                                    extends ComponentManagerWithAsyncLifeCycleCallbacks<ComponentStateBucket>,
                                                                                                                                                                                                                                                                    ComponentManagerWithUpdateHook<ComponentStateBucket> {}

                                                                                                                                                                                                                                                                      method didUpdateComponent

                                                                                                                                                                                                                                                                      didUpdateComponent: (instance: ComponentStateBucket) => void;

                                                                                                                                                                                                                                                                        interface ComponentManagerWithDestructors

                                                                                                                                                                                                                                                                        interface ComponentManagerWithDestructors<ComponentStateBucket>
                                                                                                                                                                                                                                                                        extends ComponentManager<ComponentStateBucket> {}

                                                                                                                                                                                                                                                                          method destroyComponent

                                                                                                                                                                                                                                                                          destroyComponent: (instance: ComponentStateBucket) => void;

                                                                                                                                                                                                                                                                            interface ComponentManagerWithUpdateHook

                                                                                                                                                                                                                                                                            interface ComponentManagerWithUpdateHook<ComponentStateBucket>
                                                                                                                                                                                                                                                                            extends ComponentManager<ComponentStateBucket> {}

                                                                                                                                                                                                                                                                              method updateComponent

                                                                                                                                                                                                                                                                              updateComponent: (instance: ComponentStateBucket, args: Arguments) => void;

                                                                                                                                                                                                                                                                                interface ContainingMetadata

                                                                                                                                                                                                                                                                                interface ContainingMetadata {}

                                                                                                                                                                                                                                                                                  property asPartial

                                                                                                                                                                                                                                                                                  asPartial: boolean;

                                                                                                                                                                                                                                                                                    property evalSymbols

                                                                                                                                                                                                                                                                                    evalSymbols: Option<string[]>;

                                                                                                                                                                                                                                                                                      property isStrictMode

                                                                                                                                                                                                                                                                                      isStrictMode: boolean;

                                                                                                                                                                                                                                                                                        property moduleName

                                                                                                                                                                                                                                                                                        moduleName: string;

                                                                                                                                                                                                                                                                                          property owner

                                                                                                                                                                                                                                                                                          owner: Owner | null;

                                                                                                                                                                                                                                                                                            property scopeValues

                                                                                                                                                                                                                                                                                            scopeValues: unknown[] | null;

                                                                                                                                                                                                                                                                                              property size

                                                                                                                                                                                                                                                                                              size: number;

                                                                                                                                                                                                                                                                                                property upvars

                                                                                                                                                                                                                                                                                                upvars: Option<string[]>;

                                                                                                                                                                                                                                                                                                  interface Cursor

                                                                                                                                                                                                                                                                                                  interface Cursor {}

                                                                                                                                                                                                                                                                                                    property element

                                                                                                                                                                                                                                                                                                    readonly element: SimpleElement;

                                                                                                                                                                                                                                                                                                      property nextSibling

                                                                                                                                                                                                                                                                                                      readonly nextSibling: Option<SimpleNode>;

                                                                                                                                                                                                                                                                                                        interface CustomRenderNode

                                                                                                                                                                                                                                                                                                        interface CustomRenderNode extends RenderNode {}

                                                                                                                                                                                                                                                                                                          property bucket

                                                                                                                                                                                                                                                                                                          bucket: object;

                                                                                                                                                                                                                                                                                                            interface DebugRenderTree

                                                                                                                                                                                                                                                                                                            interface DebugRenderTree<Bucket extends object = object> {}

                                                                                                                                                                                                                                                                                                              method begin

                                                                                                                                                                                                                                                                                                              begin: () => void;

                                                                                                                                                                                                                                                                                                                method capture

                                                                                                                                                                                                                                                                                                                capture: () => CapturedRenderNode[];

                                                                                                                                                                                                                                                                                                                  method commit

                                                                                                                                                                                                                                                                                                                  commit: () => void;

                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                    create: (state: Bucket, node: RenderNode) => void;

                                                                                                                                                                                                                                                                                                                      method didRender

                                                                                                                                                                                                                                                                                                                      didRender: (state: Bucket, bounds: Bounds) => void;

                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                        update: (state: Bucket) => void;

                                                                                                                                                                                                                                                                                                                          method willDestroy

                                                                                                                                                                                                                                                                                                                          willDestroy: (state: Bucket) => void;

                                                                                                                                                                                                                                                                                                                            interface Dict

                                                                                                                                                                                                                                                                                                                            interface Dict<T = unknown> {}

                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                              [key: string]: T;

                                                                                                                                                                                                                                                                                                                                interface DOMStack

                                                                                                                                                                                                                                                                                                                                interface DOMStack {}

                                                                                                                                                                                                                                                                                                                                  method appendComment

                                                                                                                                                                                                                                                                                                                                  appendComment: (string: string) => any;

                                                                                                                                                                                                                                                                                                                                    method appendDynamicFragment

                                                                                                                                                                                                                                                                                                                                    appendDynamicFragment: (value: any) => void;

                                                                                                                                                                                                                                                                                                                                      method appendDynamicHTML

                                                                                                                                                                                                                                                                                                                                      appendDynamicHTML: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                        method appendDynamicNode

                                                                                                                                                                                                                                                                                                                                        appendDynamicNode: (value: any) => void;

                                                                                                                                                                                                                                                                                                                                          method appendDynamicText

                                                                                                                                                                                                                                                                                                                                          appendDynamicText: (value: string) => any;

                                                                                                                                                                                                                                                                                                                                            method appendText

                                                                                                                                                                                                                                                                                                                                            appendText: (string: string) => any;

                                                                                                                                                                                                                                                                                                                                              method closeElement

                                                                                                                                                                                                                                                                                                                                              closeElement: () => Option<ModifierInstance[]>;

                                                                                                                                                                                                                                                                                                                                                method flushElement

                                                                                                                                                                                                                                                                                                                                                flushElement: (modifiers: Option<ModifierInstance[]>) => void;

                                                                                                                                                                                                                                                                                                                                                  method openElement

                                                                                                                                                                                                                                                                                                                                                  openElement: (tag: string, _operations?: ElementOperations) => any;

                                                                                                                                                                                                                                                                                                                                                    method popElement

                                                                                                                                                                                                                                                                                                                                                    popElement: () => void;

                                                                                                                                                                                                                                                                                                                                                      method popRemoteElement

                                                                                                                                                                                                                                                                                                                                                      popRemoteElement: () => void;

                                                                                                                                                                                                                                                                                                                                                        method pushRemoteElement

                                                                                                                                                                                                                                                                                                                                                        pushRemoteElement: (
                                                                                                                                                                                                                                                                                                                                                        element: any,
                                                                                                                                                                                                                                                                                                                                                        guid: string,
                                                                                                                                                                                                                                                                                                                                                        insertBefore: Maybe<SimpleNode>
                                                                                                                                                                                                                                                                                                                                                        ) => Option<RemoteLiveBlock>;

                                                                                                                                                                                                                                                                                                                                                          method setDynamicAttribute

                                                                                                                                                                                                                                                                                                                                                          setDynamicAttribute: (
                                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                                          value: unknown,
                                                                                                                                                                                                                                                                                                                                                          isTrusting: boolean,
                                                                                                                                                                                                                                                                                                                                                          namespace: Option<string>
                                                                                                                                                                                                                                                                                                                                                          ) => AttributeOperation;

                                                                                                                                                                                                                                                                                                                                                            method setStaticAttribute

                                                                                                                                                                                                                                                                                                                                                            setStaticAttribute: (
                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                            value: string,
                                                                                                                                                                                                                                                                                                                                                            namespace: Option<string>
                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                              interface DynamicScope

                                                                                                                                                                                                                                                                                                                                                              interface DynamicScope {}

                                                                                                                                                                                                                                                                                                                                                                method child

                                                                                                                                                                                                                                                                                                                                                                child: () => DynamicScope;

                                                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                                                  get: (key: string) => any;

                                                                                                                                                                                                                                                                                                                                                                    method set

                                                                                                                                                                                                                                                                                                                                                                    set: (key: string, reference: any) => any;

                                                                                                                                                                                                                                                                                                                                                                      interface ElementBuilder

                                                                                                                                                                                                                                                                                                                                                                      interface ElementBuilder extends Cursor, DOMStack, TreeOperations {}

                                                                                                                                                                                                                                                                                                                                                                        property [CURSOR_STACK]

                                                                                                                                                                                                                                                                                                                                                                        [CURSOR_STACK]: Stack<Cursor>;

                                                                                                                                                                                                                                                                                                                                                                          property constructing

                                                                                                                                                                                                                                                                                                                                                                          constructing: Option<SimpleElement>;

                                                                                                                                                                                                                                                                                                                                                                            property dom

                                                                                                                                                                                                                                                                                                                                                                            dom: GlimmerTreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                              property element

                                                                                                                                                                                                                                                                                                                                                                              element: SimpleElement;

                                                                                                                                                                                                                                                                                                                                                                                property hasBlocks

                                                                                                                                                                                                                                                                                                                                                                                hasBlocks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  property nextSibling

                                                                                                                                                                                                                                                                                                                                                                                  nextSibling: Option<SimpleNode>;

                                                                                                                                                                                                                                                                                                                                                                                    property updateOperations

                                                                                                                                                                                                                                                                                                                                                                                    updateOperations: GlimmerTreeChanges;

                                                                                                                                                                                                                                                                                                                                                                                      method debugBlocks

                                                                                                                                                                                                                                                                                                                                                                                      debugBlocks: () => LiveBlock[];

                                                                                                                                                                                                                                                                                                                                                                                        method didAppendBounds

                                                                                                                                                                                                                                                                                                                                                                                        didAppendBounds: (bounds: Bounds) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method popBlock

                                                                                                                                                                                                                                                                                                                                                                                          popBlock: () => LiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                            method pushBlockList

                                                                                                                                                                                                                                                                                                                                                                                            pushBlockList: (list: Bounds[]) => LiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                              method pushSimpleBlock

                                                                                                                                                                                                                                                                                                                                                                                              pushSimpleBlock: () => LiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                                method pushUpdatableBlock

                                                                                                                                                                                                                                                                                                                                                                                                pushUpdatableBlock: () => UpdatableBlock;

                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementOperations

                                                                                                                                                                                                                                                                                                                                                                                                  interface ElementOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                    method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                    setAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                                                    value: any,
                                                                                                                                                                                                                                                                                                                                                                                                    trusting: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                    namespace: Option<string>
                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method setStaticAttribute

                                                                                                                                                                                                                                                                                                                                                                                                      setStaticAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                      value: string,
                                                                                                                                                                                                                                                                                                                                                                                                      namespace: Option<string>
                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        interface Encoder

                                                                                                                                                                                                                                                                                                                                                                                                        interface Encoder {}
                                                                                                                                                                                                                                                                                                                                                                                                        • The Encoder receives a stream of opcodes from the syntax compiler and turns them into a binary program.

                                                                                                                                                                                                                                                                                                                                                                                                        method commit

                                                                                                                                                                                                                                                                                                                                                                                                        commit: (size: number) => HandleResult;
                                                                                                                                                                                                                                                                                                                                                                                                        • Finalize the current compilation unit, add a (Return), and push the opcodes from the buffer into the program. At this point, some of the opcodes might still be placeholders, such as in the case of recursively compiled templates.

                                                                                                                                                                                                                                                                                                                                                                                                          Parameter compiler

                                                                                                                                                                                                                                                                                                                                                                                                          Parameter size

                                                                                                                                                                                                                                                                                                                                                                                                        method error

                                                                                                                                                                                                                                                                                                                                                                                                        error: (error: EncoderError) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method label

                                                                                                                                                                                                                                                                                                                                                                                                          label: (name: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                          • Mark the current position with a label name. This label name can be used by any other opcode in this label block.

                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                          method push

                                                                                                                                                                                                                                                                                                                                                                                                          push: (
                                                                                                                                                                                                                                                                                                                                                                                                          constants: CompileTimeConstants,
                                                                                                                                                                                                                                                                                                                                                                                                          opcode: BuilderOpcode,
                                                                                                                                                                                                                                                                                                                                                                                                          ...args: SingleBuilderOperand[]
                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                          • Push a syscall into the program with up to three optional operands.

                                                                                                                                                                                                                                                                                                                                                                                                            Parameter opcode

                                                                                                                                                                                                                                                                                                                                                                                                            Parameter args

                                                                                                                                                                                                                                                                                                                                                                                                            up to three operands, formatted as { type: "type", value: value }

                                                                                                                                                                                                                                                                                                                                                                                                          method startLabels

                                                                                                                                                                                                                                                                                                                                                                                                          startLabels: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                          • Start a new labels block. A labels block is a scope for labels that can be referred to before they are declared. For example, when compiling an if, the JumpUnless opcode occurs before the target label. To accommodate this use-case ergonomically, the Encoder allows a syntax to create a labels block and then refer to labels that have not yet been declared. Once the block is complete, a second pass replaces the label names with offsets.

                                                                                                                                                                                                                                                                                                                                                                                                            The pattern is:

                                                                                                                                                                                                                                                                                                                                                                                                            encoder.reserve(Op.JumpUnless);
                                                                                                                                                                                                                                                                                                                                                                                                            encoder.target(encoder.pos, 'ELSE');

                                                                                                                                                                                                                                                                                                                                                                                                            The reserve method creates a placeholder opcode with space for a target in the future, and the target method registers the blank operand position to be replaced with an offset to ELSE, once it's known.

                                                                                                                                                                                                                                                                                                                                                                                                          method stopLabels

                                                                                                                                                                                                                                                                                                                                                                                                          stopLabels: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                          • Finish the current labels block and replace label names with offsets, now that all of the offsets are known.

                                                                                                                                                                                                                                                                                                                                                                                                          interface EncoderError

                                                                                                                                                                                                                                                                                                                                                                                                          interface EncoderError {}

                                                                                                                                                                                                                                                                                                                                                                                                            property problem

                                                                                                                                                                                                                                                                                                                                                                                                            problem: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property span

                                                                                                                                                                                                                                                                                                                                                                                                              span: {
                                                                                                                                                                                                                                                                                                                                                                                                              start: number;
                                                                                                                                                                                                                                                                                                                                                                                                              end: number;
                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                interface Environment

                                                                                                                                                                                                                                                                                                                                                                                                                interface Environment {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property [TransactionSymbol]

                                                                                                                                                                                                                                                                                                                                                                                                                  [TransactionSymbol]: Option<Transaction>;

                                                                                                                                                                                                                                                                                                                                                                                                                    property debugRenderTree

                                                                                                                                                                                                                                                                                                                                                                                                                    debugRenderTree?: DebugRenderTree;

                                                                                                                                                                                                                                                                                                                                                                                                                      property isInteractive

                                                                                                                                                                                                                                                                                                                                                                                                                      isInteractive: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        method begin

                                                                                                                                                                                                                                                                                                                                                                                                                        begin: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method commit

                                                                                                                                                                                                                                                                                                                                                                                                                          commit: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            method didCreate

                                                                                                                                                                                                                                                                                                                                                                                                                            didCreate: (component: ComponentInstanceWithCreate) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method didUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                              didUpdate: (component: ComponentInstanceWithCreate) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getAppendOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                getAppendOperations: () => GlimmerTreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDOM

                                                                                                                                                                                                                                                                                                                                                                                                                                  getDOM: () => GlimmerTreeChanges;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method scheduleInstallModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                    scheduleInstallModifier: (modifier: ModifierInstance) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method scheduleUpdateModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                      scheduleUpdateModifier: (modifier: ModifierInstance) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EnvironmentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EnvironmentOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property appendOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                          appendOperations?: GlimmerTreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property document

                                                                                                                                                                                                                                                                                                                                                                                                                                            document?: SimpleDocument;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property updateOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                              updateOperations?: GlimmerTreeChanges;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ErrHandle

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ErrHandle {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                  errors: EncoderError[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                    handle: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EvalSymbolsOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EvalSymbolsOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: HighLevelOperand.EvalSymbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExceptionHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExceptionHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleException

                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleException: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GlimmerDOMOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GlimmerDOMOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createComment: (data: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createElement: (tag: string, context?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createTextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createTextNode: (text: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method insertBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        insertBefore: (parent: any, node: any, reference: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method insertHTMLBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          insertHTMLBefore: (parent: any, nextSibling: any, html: string) => Bounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GlimmerTreeChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GlimmerTreeChanges extends GlimmerDOMOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method insertAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              insertAfter: (element: any, node: any, reference: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeAttribute: (element: any, name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setAttribute: (element: any, name: string, value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GlimmerTreeConstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface GlimmerTreeConstruction extends GlimmerDOMOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      element: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Helper<O extends Owner = Owner> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          args: CapturedArguments,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          owner: O | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dynamicScope?: DynamicScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface HelperCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface HelperCapabilities extends Capabilities {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hasDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasDestroyable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property hasScheduledEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hasScheduledEffect: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasValue: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HelperCapabilitiesVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HelperCapabilitiesVersions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property '3.23'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      '3.23': {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hasValue?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hasDestroyable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HelperManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HelperManager<HelperStateBucket> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          capabilities: HelperCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createHelper: (definition: object, args: Arguments) => HelperStateBucket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDebugName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDebugName: (definition: object) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface HelperManagerWithDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface HelperManagerWithDestroyable<HelperStateBucket>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends HelperManager<HelperStateBucket> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDestroyable: (bucket: HelperStateBucket) => object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HelperManagerWithValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface HelperManagerWithValue<HelperStateBucket>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extends HelperManager<HelperStateBucket> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getValue: (bucket: HelperStateBucket) => unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface InstructionEncoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface InstructionEncoder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly buffer: CompilerBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encode: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: MachineOp,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              machine: OpcodeSize.MACHINE_MASK,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...operands: Operand[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (type: Op, machine: 0, ...operands: number[]): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                patch: (position: number, target: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InternalComponentCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InternalComponentCapabilities {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Describes the capabilities of a particular component. The capabilities are provided to the Glimmer compiler and VM via the ComponentDefinition, which includes a ComponentCapabilities record.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Certain features in the VM come with some overhead, so the compiler and runtime use this information to skip unnecessary work for component types that don't need it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For example, a component that is template-only (i.e., it does not have an associated JavaScript class to instantiate) can skip invoking component manager hooks related to lifecycle events by setting the elementHook capability to false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property attributeHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attributeHook: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether to call the didSplatAttributes hook on the component manager.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property createArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createArgs: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether a reified Arguments object will get passed to the component manager's create hook. If a particular component does not access passed arguments from JavaScript (via the this.args property in Glimmer.js, for example), this flag can be set to false to avoid the work of instantiating extra data structures to expose the arguments to JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property createCaller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createCaller: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether the component needs the caller component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property createInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createInstance: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether there is a component instance to create. If this is false, the component is a "template only component"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dynamicLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dynamicLayout: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether a component's template is static across all instances of that component, or can vary per instance. This should usually be false except for cases of backwards-compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dynamicScope: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether the component needs an additional dynamic scope frame.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dynamicTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dynamicTag: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether a "wrapped" component's root element can change after being rendered. This flag is only used by the WrappedBuilder and should be false except for cases of backwards-compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property elementHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elementHook: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether to call the didCreateElement hook on the component manager.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasSubOwner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasSubOwner: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether or not the component pushes an owner onto the owner stack. This is used for engines.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property prepareArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prepareArgs: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Setting the prepareArgs flag to true enables the prepareArgs hook on the component manager, which would otherwise not be called.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The component manager's prepareArgs hook allows it to programmatically add or remove positional and named arguments for a component before the component is invoked. This flag should usually be false except for cases of backwards-compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property updateHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateHook: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether the component manager has an update hook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property willDestroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  willDestroy: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Whether or not the component has a willDestroy hook that should fire prior to the component being removed from the DOM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property wrapped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wrapped: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalComponentManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalComponentManager<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TComponentStateBucket = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TComponentDefinition = object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getCapabilities: (state: TComponentDefinition) => InternalComponentCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDebugName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDebugName: (state: TComponentDefinition) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDestroyable: (state: TComponentStateBucket) => Option<Destroyable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getSelf: (state: TComponentStateBucket) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InternalHelperManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InternalHelperManager<TOwner extends Owner> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getDelegateFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getDelegateFor: (owner: TOwner | undefined) => HelperManager<unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getHelper: (definition: HelperDefinitionState) => Helper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalModifierManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InternalModifierManager<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TModifierInstanceState = ModifierInstanceState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TModifierDefinitionState extends ModifierDefinitionState = ModifierDefinitionState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      owner: Owner,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      element: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: TModifierDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: CapturedArguments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => TModifierInstanceState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDebugName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDebugName: (Modifier: TModifierDefinitionState) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDestroyable: (modifier: TModifierInstanceState) => Destroyable | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getTag: (modifier: TModifierInstanceState) => UpdatableTag | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method install

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              install: (modifier: TModifierInstanceState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                update: (modifier: TModifierInstanceState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Invocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Invocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handle: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property symbolTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      symbolTable: ProgramSymbolTable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IsStrictModeOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IsStrictModeOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: HighLevelOperand.IsStrictMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonArray extends Array<JsonValue> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JsonObject extends Dict<JsonValue> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LabelOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LabelOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: HighLevelOperand.Label;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LayoutOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LayoutOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: HighLevelOperand.Layout;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: CompilableTemplate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LayoutWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LayoutWithContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property asPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly asPartial: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly block: SerializedTemplateBlock;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isStrictMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isStrictMode: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly moduleName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly owner: Owner | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly scope: (() => unknown[]) | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LiveBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LiveBlock extends Bounds {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method closeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closeElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method didAppendBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  didAppendBounds: (bounds: Bounds) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method didAppendNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    didAppendNode: (node: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      finalize: (stack: ElementBuilder) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method openElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openElement: (element: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ModifierCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ModifierCapabilities extends Capabilities {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property disableAutoTracking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            disableAutoTracking: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property passFactoryToCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              passFactoryToCreate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property useArgsProxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                useArgsProxy: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModifierCapabilitiesVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModifierCapabilitiesVersions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property '3.13'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    '3.13': {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disableAutoTracking?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property '3.22'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      '3.22': {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disableAutoTracking?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierDefinition<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        D extends ModifierDefinitionState = ModifierDefinitionState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property manager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          manager: InternalModifierManager<I, D>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resolvedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolvedName: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              state: ModifierDefinitionState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModifierInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModifierInstance {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property definition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  definition: ModifierDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property manager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    manager: InternalModifierManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: ModifierInstanceState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierManager<ModifierStateBucket> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          capabilities: ModifierCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createModifier: (factory: unknown, args: Arguments) => ModifierStateBucket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method destroyModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              destroyModifier: (instance: ModifierStateBucket, args: Arguments) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method installModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                installModifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                instance: ModifierStateBucket,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                element: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: Arguments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method updateModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateModifier: (instance: ModifierStateBucket, args: Arguments) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NamedArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NamedArguments {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        names: readonly string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method capture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          capture: () => CapturedNamedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            get: (name: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NamedBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NamedBlocks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasAny

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasAny: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    names: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      get: (name: string) => SerializedInlineBlock;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method with

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          with: (name: string, block: SerializedInlineBlock) => NamedBlocks;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeTokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeTokens {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method reify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reify: (token: NodeToken) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NonSmallIntOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NonSmallIntOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: HighLevelOperand.NonSmallInt;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OpcodeHeap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OpcodeHeap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getbyaddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getbyaddr: (address: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PartialDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PartialDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPartial: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: CompileTimeCompilationContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => { symbolTable: ProgramSymbolTable; handle: HandleResult };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PartialScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PartialScope extends Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bindEvalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bindEvalScope: (scope: Option<Dict<ScopeSlot>>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PositionalArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PositionalArguments {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        at: (position: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method capture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          capture: () => CapturedPositionalArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PreparedArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PreparedArguments {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property named

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              named: Dict<Reference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property positional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                positional: ReadonlyArray<Reference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgramSymbolTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgramSymbolTable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasEval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasEval: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      symbols: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Reifiable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Reifiable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method reify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reify: (tokens: NodeTokens) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RemoteLiveBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RemoteLiveBlock extends SimpleLiveBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RenderNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RenderNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: CapturedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  instance: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      template?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: RenderNodeType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RenderResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RenderResult extends Bounds, ExceptionHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property drop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly drop: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly env: Environment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method firstNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                firstNode: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method lastNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lastNode: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method parentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parentElement: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method rerender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rerender: (options?: { alwaysRevalidate: false }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolutionTimeConstants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolutionTimeConstants {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Resolution happens when components are first loaded, either via the resolver or via looking them up in template scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultTemplate: Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          component: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          definitionState: ComponentDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          owner: object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isOptional?: false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): ComponentDefinition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          definitionState: object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          owner: object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isOptional?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): ComponentDefinition<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          InternalComponentManager<unknown, object>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            helper: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            definitionState: HelperDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolvedName: string | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isOptional: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (definitionState: object, resolvedName?: string): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method modifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              modifier: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              definitionState: ModifierDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolvedName: string | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isOptional: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (definitionState: object, resolvedName?: string): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method resolvedComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolvedComponent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                definitionState: ResolvedComponentDefinition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolvedName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ComponentDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResolvedComponentDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResolvedComponentDefinition<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  D = ComponentDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  I = ComponentInstanceState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property manager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    manager: M;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        template: Template | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ResolvedLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ResolvedLayout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            capabilities: InternalComponentCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property compilable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              compilable: Option<CompilableProgram>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handle: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuntimeArtifacts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuntimeArtifacts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly constants: RuntimeConstants & ResolutionTimeConstants;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property heap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly heap: RuntimeHeap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuntimeConstants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuntimeConstants {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getArray: <T>(handle: number) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getValue: <T>(handle: number) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RuntimeContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RuntimeContext {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The Runtime is the set of static structures that contain the compiled code and any host configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The contents of the Runtime do not change as the VM executes, unlike the VM state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              env: Environment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                program: RuntimeProgram;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property resolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolver: RuntimeResolver;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuntimeHeap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuntimeHeap extends OpcodeHeap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getaddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getaddr: (handle: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sizeof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sizeof: (handle: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuntimeOp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuntimeOp {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isMachine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isMachine: 0 | 1;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property op1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                op1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property op2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  op2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property op3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    op3: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuntimeProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuntimeProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly constants: RuntimeConstants & ResolutionTimeConstants;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property heap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly heap: RuntimeHeap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method opcode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: (offset: number) => RuntimeOp;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuntimeResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuntimeResolver<O extends Owner = Owner> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method lookupComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lookupComponent: (name: string, owner: O) => Option<ResolvedComponentDefinition>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method lookupPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lookupPartial: (name: string, owner: O) => Option<PartialDefinition>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property owner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly owner: Owner;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property slots

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly slots: Array<ScopeSlot>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method bind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bind: (symbol: number, value: ScopeSlot) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bindBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindBlock: (symbol: number, value: ScopeBlock) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bindEvalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bindEvalScope: (map: Option<Dict<ScopeSlot>>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method bindPartialMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bindPartialMap: (map: Dict<Reference>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method bindSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bindSelf: (self: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method bindSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bindSymbol: (symbol: number, value: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          child: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getBlock: (symbol: number) => ScopeBlock;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getEvalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getEvalScope: () => Option<Dict<ScopeSlot>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPartialMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getPartialMap: () => Option<Dict<Reference>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getSelf: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getSymbol: (symbol: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SerializedHeap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SerializedHeap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        buffer: ArrayBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          handle: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            table: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SerializedTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SerializedTemplate {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A JSON object that the compiled Template was serialized into.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              block: SerializedTemplateBlock;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: Option<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  moduleName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SerializedTemplateWithLazyBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SerializedTemplateWithLazyBlock {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A JSON object containing the SerializedTemplateBlock as JSON and TemplateMeta.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    block: SerializedTemplateBlockJSON;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: Option<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isStrictMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isStrictMode: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          moduleName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scope: (() => unknown[]) | undefined | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SexpOpcodeMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SexpOpcodeMap extends ExpressionSexpOpcodeMap, StatementSexpOpcodeMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleArgsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SimpleArgsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property atNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  atNames: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property named

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    named: Option<WireFormat.Core.Hash>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property positional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      positional: Option<WireFormat.Core.Params>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleLiveBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleLiveBlock extends LiveBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method firstNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          firstNode: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method lastNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lastNode: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parentElement: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SpecTreeConstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SpecTreeConstruction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method appendComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  appendComment: (text: string) => NodeToken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method appendText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appendText: (text: string) => NodeToken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method appendTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      appendTo: (parent: SimpleElement | SimpleDocumentFragment) => NodeTokens;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method closeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        closeElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method openElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          openElement: (name: string, ns?: any) => NodeToken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setAttribute: (name: string, value: string, namespace?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Stack<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                current: Option<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method nth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nth: (from: number) => Option<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pop: () => Option<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          push: (item: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toArray: () => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface STDLib

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface STDLib {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'cautious-append'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'cautious-append': number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'cautious-non-dynamic-append'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'cautious-non-dynamic-append': number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'trusting-append'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'trusting-append': number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'trusting-non-dynamic-append'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'trusting-non-dynamic-append': number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property main

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        main: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StdLibOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StdLibOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: HighLevelOperand.StdLib;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'main'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'trusting-append'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'cautious-append'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'trusting-non-dynamic-append'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'cautious-non-dynamic-append';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SymbolTableOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SymbolTableOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: HighLevelOperand.SymbolTable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: SymbolTable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TemplateCompilationContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TemplateCompilationContext {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Options for compiling a specific template. This carries along the static information associated with the entire template when compiling blocks nested inside of it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property encoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly encoder: Encoder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly meta: ContainingMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly program: CompileTimeCompilationContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TemplateError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TemplateError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property problem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              problem: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                result: 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property span

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  span: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TemplateIterator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TemplateIterator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      next: () => RichIteratorResult<null, RenderResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sync: () => RenderResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TemplateOk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TemplateOk {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Environment specific template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          moduleName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Module name associated with the template, used for debugging purposes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property result

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          result: 'ok';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method asLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            asLayout: () => CompilableProgram;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method asPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              asPartial: () => CompilableProgram;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method asWrappedLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                asWrappedLayout: () => CompilableProgram;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Transaction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TreeOperations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TreeOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Unique

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Unique<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'Unique [id=ada0f31f-27f7-4ab0-bc03-0005387c9d5f]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'Unique [id=ada0f31f-27f7-4ab0-bc03-0005387c9d5f]': T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdatableBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UpdatableBlock extends SimpleLiveBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reset: (env: Environment) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UpdatingOpcode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UpdatingOpcode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method evaluate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                evaluate: (vm: UpdatingVM) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UpdatingVM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UpdatingVM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property alwaysRevalidate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alwaysRevalidate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dom: GlimmerTreeChanges;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        env: Environment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method execute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          execute: (opcodes: UpdatingOpcode[], handler: ExceptionHandler) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method goto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            goto: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              throw: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method try

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                try: (ops: UpdatingOpcode[], handler: ExceptionHandler | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VM<O extends Owner = Owner> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This is used in the Glimmer Embedding API. In particular, embeddings provide helpers through the CompileTimeLookup interface, and the helpers they provide implement the Helper interface, which is a function that takes a VM as a parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  env: Environment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method associateDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    associateDestroyable: (child: Destroyable) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method dynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dynamicScope: () => DynamicScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getOwner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getOwner: () => O;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSelf: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VMArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VMArguments {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property named

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                named: NamedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property positional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  positional: PositionalArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    at: (pos: number