@glimmer/interfaces

  • Version 0.84.2
  • Published
  • 73 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: () => SimpleNode;

                                                                      method lastNode

                                                                      lastNode: () => SimpleNode;

                                                                        method parentElement

                                                                        parentElement: () => SimpleElement;

                                                                          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>;

                                                                                                                                                                                                          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 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) => SimpleComment;

                                                                                                                                                                                                                                                                                                                                method appendDynamicFragment

                                                                                                                                                                                                                                                                                                                                appendDynamicFragment: (value: SimpleDocumentFragment) => void;

                                                                                                                                                                                                                                                                                                                                  method appendDynamicHTML

                                                                                                                                                                                                                                                                                                                                  appendDynamicHTML: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                    method appendDynamicNode

                                                                                                                                                                                                                                                                                                                                    appendDynamicNode: (value: SimpleNode) => void;

                                                                                                                                                                                                                                                                                                                                      method appendDynamicText

                                                                                                                                                                                                                                                                                                                                      appendDynamicText: (value: string) => SimpleText;

                                                                                                                                                                                                                                                                                                                                        method appendText

                                                                                                                                                                                                                                                                                                                                        appendText: (string: string) => SimpleText;

                                                                                                                                                                                                                                                                                                                                          method closeElement

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

                                                                                                                                                                                                                                                                                                                                            method flushElement

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

                                                                                                                                                                                                                                                                                                                                              method openElement

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

                                                                                                                                                                                                                                                                                                                                                method popElement

                                                                                                                                                                                                                                                                                                                                                popElement: () => void;

                                                                                                                                                                                                                                                                                                                                                  method popRemoteElement

                                                                                                                                                                                                                                                                                                                                                  popRemoteElement: () => void;

                                                                                                                                                                                                                                                                                                                                                    method pushRemoteElement

                                                                                                                                                                                                                                                                                                                                                    pushRemoteElement: (
                                                                                                                                                                                                                                                                                                                                                    element: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                    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) => Reference<unknown>;

                                                                                                                                                                                                                                                                                                                                                                method set

                                                                                                                                                                                                                                                                                                                                                                set: (key: string, reference: Reference<unknown>) => Reference<unknown>;

                                                                                                                                                                                                                                                                                                                                                                  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: Reference,
                                                                                                                                                                                                                                                                                                                                                                                                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) => SimpleComment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createTextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createTextNode: (text: string) => SimpleText;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method insertBefore

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method insertHTMLBefore

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GlimmerTreeChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GlimmerTreeChanges extends GlimmerDOMOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method insertAfter

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method removeAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GlimmerTreeConstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GlimmerTreeConstruction extends GlimmerDOMOperations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace?: Namespace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => 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) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 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: SimpleNode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method finalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                finalize: (stack: ElementBuilder) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method openElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  openElement: (element: SimpleElement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ModifierCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ModifierCapabilities extends Capabilities {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disableAutoTracking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disableAutoTracking: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierCapabilitiesVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModifierCapabilitiesVersions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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) => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NonSmallIntOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NonSmallIntOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: HighLevelOperand.NonSmallInt;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OpcodeHeap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OpcodeHeap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getbyaddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getbyaddr: (address: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: () => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method lastNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lastNode: () => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentElement: () => SimpleElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: Reference) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method bindSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bindSymbol: (symbol: number, value: Reference) => 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: () => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getSymbol: (symbol: number) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: () => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method lastNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lastNode: () => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method parentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parentElement: () => SimpleElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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?: Namespace) => NodeToken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setAttribute: (name: string, value: string, namespace?: Namespace) => 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 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) => SimpleNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: () => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface VMArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface VMArguments {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property named

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          named: NamedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property positional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            positional: PositionalArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              at: (pos: number) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method capture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                capture: () => CapturedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WithAttributeHook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WithAttributeHook<ComponentInstanceState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends InternalComponentManager<ComponentInstanceState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method didSplatAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    didSplatAttributes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    component: ComponentInstanceState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    element: ComponentInstanceState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operations: ElementOperations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface WithCreateInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface WithCreateInstance<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ComponentInstanceState = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ComponentDefinitionState = unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends Owner = Owner
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > extends InternalComponentManager<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ComponentInstanceState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ComponentDefinitionState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        owner: O,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state: ComponentDefinitionState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: Option<VMArguments>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        env: Environment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dynamicScope: Option<DynamicScope>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        caller: Reference,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasDefaultBlock: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ComponentInstanceState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method didCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          didCreate: (state: ComponentInstanceState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method didRenderLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            didRenderLayout: (state: ComponentInstanceState, bounds: Bounds) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method didUpdate