@glimmer/interfaces

  • Version 0.92.0
  • Published
  • 81.1 kB
  • 1 dependency
  • MIT license

Install

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

Overview

Overview not available.

Index

Variables

Functions

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CAPABILITIES

const CAPABILITIES: Symbol;

    variable CapabilityBrand

    const CapabilityBrand: Symbol;

      variable CAPTURED_ARGS

      const CAPTURED_ARGS: Symbol;

        variable COMPUTE

        const COMPUTE: Symbol;

          variable CURSOR_STACK

          const CURSOR_STACK: Symbol;

            variable REFERENCE

            const REFERENCE: Symbol;

              variable TransactionSymbol

              const TransactionSymbol: Symbol;

                variable TYPE

                const TYPE: Symbol;

                  Functions

                  function isArgumentError

                  isArgumentError: (arg: unknown) => arg is ArgumentError;

                    Interfaces

                    interface ArgsOptions

                    interface ArgsOptions extends SimpleArgsOptions {}

                      property blocks

                      blocks: NamedBlocks;

                        property named

                        named: WireFormat.Core.Hash;

                          interface ArgumentError

                          interface ArgumentError {}

                            property error

                            error: any;

                              interface Arguments

                              interface Arguments {}

                                property named

                                named: Record<string, unknown>;

                                  property positional

                                  positional: readonly unknown[];

                                    interface ArgumentsDebug

                                    interface ArgumentsDebug {}

                                      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: Nullable<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: BlockOperandType;

                                                                          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 extends Record<string, Reference> {}

                                                                                                                      property [CAPTURED_ARGS]

                                                                                                                      [CAPTURED_ARGS]: true;

                                                                                                                        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 CombinatorTag

                                                                                                                                              interface CombinatorTag extends MonomorphicTag {}

                                                                                                                                                property [TYPE]

                                                                                                                                                readonly [TYPE]: COMBINATOR_TAG_ID;

                                                                                                                                                  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 createOp

                                                                                                                                                                            readonly createOp: CreateRuntimeOp;

                                                                                                                                                                              property heap

                                                                                                                                                                              readonly heap: CompileTimeHeap;

                                                                                                                                                                                property resolver

                                                                                                                                                                                readonly resolver: CompileTimeResolver;

                                                                                                                                                                                  property stdlib

                                                                                                                                                                                  readonly stdlib: STDLib;

                                                                                                                                                                                    interface CompileTimeComponent

                                                                                                                                                                                    interface CompileTimeComponent {}

                                                                                                                                                                                      property capabilities

                                                                                                                                                                                      capabilities: CapabilityMask;

                                                                                                                                                                                        property compilable

                                                                                                                                                                                        compilable: Nullable<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 pushMachine

                                                                                                                                                                                                                pushMachine: (
                                                                                                                                                                                                                name: VmMachineOp,
                                                                                                                                                                                                                op1?: number,
                                                                                                                                                                                                                op2?: number,
                                                                                                                                                                                                                op3?: number
                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                  method pushOp

                                                                                                                                                                                                                  pushOp: (name: VmOp, op1?: number, op2?: number, op3?: number) => void;

                                                                                                                                                                                                                    method pushRaw

                                                                                                                                                                                                                    pushRaw: (value: 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) => Nullable<HelperDefinitionState>;

                                                                                                                                                                                                                              method lookupBuiltInModifier

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

                                                                                                                                                                                                                                method lookupComponent

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

                                                                                                                                                                                                                                  method lookupHelper

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

                                                                                                                                                                                                                                    method lookupModifier

                                                                                                                                                                                                                                    lookupModifier: (name: string, owner: O) => Nullable<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: CapabilityMask;

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

                                                                                                                                                                                                                                                                      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 ConstantTag

                                                                                                                                                                                                                                                                                                          interface ConstantTag extends MonomorphicTag {}

                                                                                                                                                                                                                                                                                                            property [TYPE]

                                                                                                                                                                                                                                                                                                            readonly [TYPE]: CONSTANT_TAG_ID;

                                                                                                                                                                                                                                                                                                              interface ContainingMetadata

                                                                                                                                                                                                                                                                                                              interface ContainingMetadata {}

                                                                                                                                                                                                                                                                                                                property evalSymbols

                                                                                                                                                                                                                                                                                                                evalSymbols: Nullable<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: Nullable<string[]>;

                                                                                                                                                                                                                                                                                                                              interface Cursor

                                                                                                                                                                                                                                                                                                                              interface Cursor {}

                                                                                                                                                                                                                                                                                                                                property element

                                                                                                                                                                                                                                                                                                                                readonly element: SimpleElement;

                                                                                                                                                                                                                                                                                                                                  property nextSibling

                                                                                                                                                                                                                                                                                                                                  readonly nextSibling: Nullable<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 DebugSymbolsOperand

                                                                                                                                                                                                                                                                                                                                                        interface DebugSymbolsOperand {}

                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                          type: DebugSymbolsOperandType;

                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                            value: undefined;

                                                                                                                                                                                                                                                                                                                                                              interface DirtyableTag

                                                                                                                                                                                                                                                                                                                                                              interface DirtyableTag extends MonomorphicTag {}

                                                                                                                                                                                                                                                                                                                                                                property [TYPE]

                                                                                                                                                                                                                                                                                                                                                                readonly [TYPE]: DIRTYABLE_TAG_ID;

                                                                                                                                                                                                                                                                                                                                                                  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: () => Nullable<ModifierInstance[]>;

                                                                                                                                                                                                                                                                                                                                                                                  method flushElement

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

                                                                                                                                                                                                                                                                                                                                                                                    method openElement

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

                                                                                                                                                                                                                                                                                                                                                                                      method popElement

                                                                                                                                                                                                                                                                                                                                                                                      popElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                        method popRemoteElement

                                                                                                                                                                                                                                                                                                                                                                                        popRemoteElement: () => RemoteLiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                          method pushRemoteElement

                                                                                                                                                                                                                                                                                                                                                                                          pushRemoteElement: (
                                                                                                                                                                                                                                                                                                                                                                                          element: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                                          guid: string,
                                                                                                                                                                                                                                                                                                                                                                                          insertBefore: SimpleNode
                                                                                                                                                                                                                                                                                                                                                                                          ) => RemoteLiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                            method setDynamicAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                              method setStaticAttribute

                                                                                                                                                                                                                                                                                                                                                                                              setStaticAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                                                              value: string,
                                                                                                                                                                                                                                                                                                                                                                                              namespace: Nullable<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: Nullable<SimpleElement>;

                                                                                                                                                                                                                                                                                                                                                                                                              property dom

                                                                                                                                                                                                                                                                                                                                                                                                              dom: GlimmerTreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                                                                property element

                                                                                                                                                                                                                                                                                                                                                                                                                element: SimpleElement;

                                                                                                                                                                                                                                                                                                                                                                                                                  property hasBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                  hasBlocks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                    property nextSibling

                                                                                                                                                                                                                                                                                                                                                                                                                    nextSibling: Nullable<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: Nullable<string>
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method setStaticAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                        setStaticAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                        value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace: Nullable<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]: Nullable<Transaction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property debugRenderTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                      debugRenderTree?: DebugRenderTree | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isArgumentCaptureError

                                                                                                                                                                                                                                                                                                                                                                                                                                                        isArgumentCaptureError?: ((error: any) => boolean) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: PresentArray<EncoderError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handle: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: VmMachineOp, machine: MACHINE_MASK, ...operands: Operand[]): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (type: VmOp, 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) => Nullable<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 getDebugInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDebugInstance: (Modifier: TModifierInstanceState) => unknown;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LabelOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LabelOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: LabelOperandType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LayoutOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LayoutOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: LayoutOperandType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 MonomorphicTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MonomorphicTag extends Tag {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property [TYPE]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [TYPE]: MonomorphicTagId;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OpcodeHeap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OpcodeHeap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getbyaddr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getbyaddr: (address: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PartialScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PartialScope extends Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method bindEvalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bindEvalScope: (scope: Nullable<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 Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Reference<T = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property [REFERENCE]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [REFERENCE]: ReferenceType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children: null | Map<string | Reference, Reference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property compute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                compute: Nullable<() => T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property debugLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  debugLabel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReferenceTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReferenceTypes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Compute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly Compute: ComputeReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Constant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly Constant: ConstantReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Invokable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly Invokable: InvokableReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Unbound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly Unbound: UnboundReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Reifiable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Reifiable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method reify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reify: (tokens: NodeTokens) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RenderNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RenderNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: CapturedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      instance: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          template?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: Nullable<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: SomeVmOp;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Nullable<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: Nullable<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: () => Nullable<Dict<ScopeSlot>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getPartialMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getPartialMap: () => Nullable<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?: Nullable<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?: Nullable<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: Nullable<WireFormat.Core.Hash>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property positional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        positional: Nullable<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: Nullable<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method nth

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pop: () => Nullable<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: StdLibOperandType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SymbolTableOperand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SymbolTableOperand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: SymbolTableOperandType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: SymbolTable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Tag {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property [TYPE]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly [TYPE]: TagId;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property subtag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly subtag?: Tag | Tag[] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method [COMPUTE]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [COMPUTE]: () => Revision;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UpdatableTag extends MonomorphicTag {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property [TYPE]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly [TYPE]: UPDATABLE_TAG_ID;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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;