@glimmer/runtime

  • Version 0.88.1
  • Published
  • 967 kB
  • 12 dependencies
  • MIT license

Install

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

Overview

Minimal runtime needed to render Glimmer templates

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ARGS

const ARGS: Symbol;

    variable ARGS$0

    const ARGS$0: Symbol;

      variable array

      const array: {};
      • Use the {{array}} helper to create an array to pass as an option to your components.

        ```handlebars <MyComponent @people={{array 'Tom Dale' 'Yehuda Katz' this.myOtherPerson}} /> ``` or ```handlebars {{my-component people=(array 'Tom Dale' 'Yehuda Katz' this.myOtherPerson) }} ```

        Would result in an object such as:

        ```js ['Tom Dale', 'Yehuda Katz', this.get('myOtherPerson')] ```

        Where the 3rd item in the array is bound to updates of the myOtherPerson property.

        array

        Parameter options

        {Array} Array

        Modifiers

        • @public

      variable concat

      const concat: {};
      • Concatenates the given arguments into a string.

        Example:

        ```handlebars {{some-component name=(concat firstName " " lastName)}}

        {{! would pass name="<first name value> <last name value>" to the component}} ```

        or for angle bracket invocation, you actually don't need concat at all.

        ```handlebars <SomeComponent @name="{{firstName}} {{lastName}}" /> ```

        concat

        Modifiers

        • @public

      variable CONSTANTS

      const CONSTANTS: Symbol;

        variable CURSOR_STACK

        const CURSOR_STACK: CursorStackSymbol;

          variable DESTROYABLE_STACK

          const DESTROYABLE_STACK: Symbol;

            variable DOMChanges

            const DOMChanges: typeof DOMChangesImpl;

              variable DOMTreeConstruction

              const DOMTreeConstruction: typeof TreeConstruction;

                variable EMPTY_ARGS

                const EMPTY_ARGS: CapturedArguments;

                  variable EMPTY_NAMED

                  const EMPTY_NAMED: CapturedNamedArguments;

                    variable EMPTY_POSITIONAL

                    const EMPTY_POSITIONAL: CapturedPositionalArguments;

                      variable fn

                      const fn: {};
                      • The fn helper allows you to ensure a function that you are passing off to another component, helper, or modifier has access to arguments that are available in the template.

                        For example, if you have an each helper looping over a number of items, you may need to pass a function that expects to receive the item as an argument to a component invoked within the loop. Here's how you could use the fn helper to pass both the function and its arguments together:

                        ```app/templates/components/items-listing.hbs {{#each as |item|}} <DisplayItem @item=item @select={{fn this.handleSelected item}} /> {{/each}} ```

                        ```app/components/items-list.js import Component from '@glimmer/component'; import { action } from '@ember/object';

                        export default class ItemsList extends Component { handleSelected = (item) => { // ...snip... } } ```

                        In this case the display-item component will receive a normal function that it can invoke. When it invokes the function, the handleSelected function will receive the item and any arguments passed, thanks to the fn helper.

                        Let's take look at what that means in a couple circumstances:

                        - When invoked as this.args.select() the handleSelected function will receive the item from the loop as its first and only argument. - When invoked as this.args.select('foo') the handleSelected function will receive the item from the loop as its first argument and the string 'foo' as its second argument.

                        In the example above, we used an arrow function to ensure that handleSelected is properly bound to the items-list, but let's explore what happens if we left out the arrow function:

                        ```app/components/items-list.js import Component from '@glimmer/component';

                        export default class ItemsList extends Component { handleSelected(item) { // ...snip... } } ```

                        In this example, when handleSelected is invoked inside the display-item component, it will **not** have access to the component instance. In other words, it will have no this context, so please make sure your functions are bound (via an arrow function or other means) before passing into fn!

                        See also [partial application](https://en.wikipedia.org/wiki/Partial_application).

                        fn

                        Modifiers

                        • @public

                      variable get

                      const get: {};
                      • Dynamically look up a property on an object. The second argument to {{get}} should have a string value, although it can be bound.

                        For example, these two usages are equivalent:

                        ```app/components/developer-detail.js import Component from '@glimmer/component'; import { tracked } from '@glimmer/tracking';

                        export default class extends Component { developer = { name: "Sandi Metz", language: "Ruby" } } ```

                        ```handlebars {{this.developer.name}} {{get this.developer "name"}} ```

                        If there were several facts about a person, the {{get}} helper can dynamically pick one:

                        ```app/templates/application.hbs <DeveloperDetail @factName="language" /> ```

                        ```handlebars {{get this.developer @factName}} ```

                        For a more complex example, this template would allow the user to switch between showing the user's height and weight with a click:

                        ```app/components/developer-detail.js import Component from '@glimmer/component'; import { tracked } from '@glimmer/tracking';

                        export default class extends Component { developer = { name: "Sandi Metz", language: "Ruby" }

                        currentFact = 'name'

                        showFact = (fact) => { this.currentFact = fact; } } ```

                        ```app/components/developer-detail.js {{get this.developer this.currentFact}}

                        <button {{on 'click' (fn this.showFact "name")}}>Show name <button {{on 'click' (fn this.showFact "language")}}>Show language ```

                        The {{get}} helper can also respect mutable values itself. For example:

                        ```app/components/developer-detail.js <Input @value={{mut (get this.person this.currentFact)}} />

                        <button {{on 'click' (fn this.showFact "name")}}>Show name <button {{on 'click' (fn this.showFact "language")}}>Show language ```

                        Would allow the user to swap what fact is being displayed, and also edit that fact via a two-way mutable binding.

                        get

                        Modifiers

                        • @public

                      variable hash

                      const hash: {};
                      • Use the {{hash}} helper to create a hash to pass as an option to your components. This is specially useful for contextual components where you can just yield a hash:

                        ```handlebars {{yield (hash name='Sarah' title=office )}} ```

                        Would result in an object such as:

                        ```js { name: 'Sarah', title: this.get('office') } ```

                        Where the title is bound to updates of the office property.

                        Note that the hash is an empty object with no prototype chain, therefore common methods like toString are not available in the resulting hash. If you need to use such a method, you can use the call or apply approach:

                        ```js function toString(obj) { return Object.prototype.toString.apply(obj); } ```

                        hash

                        Parameter options

                        {Object} Hash

                        Modifiers

                        • @public

                      variable HEAP

                      const HEAP: Symbol;

                        variable INNER

                        const INNER: Symbol;

                          variable INNER_VM

                          const INNER_VM: Symbol;

                            variable on

                            const on: {};

                              variable OWNER

                              const OWNER: Symbol;

                                variable REGISTERS

                                const REGISTERS: Symbol;

                                  variable RESOLVED

                                  const RESOLVED: Symbol;

                                    variable SERIALIZATION_FIRST_NODE_STRING

                                    const SERIALIZATION_FIRST_NODE_STRING: string;

                                      variable STACKS

                                      const STACKS: Symbol;

                                        variable TEMPLATE_ONLY_COMPONENT_MANAGER

                                        const TEMPLATE_ONLY_COMPONENT_MANAGER: TemplateOnlyComponentManager;

                                          variable TRANSACTION

                                          const TRANSACTION: TransactionSymbol;

                                            variable TYPE

                                            const TYPE: Symbol;

                                              Functions

                                              function clear

                                              clear: (bounds: Bounds) => Nullable<SimpleNode>;

                                                function clientBuilder

                                                clientBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

                                                  function createCapturedArgs

                                                  createCapturedArgs: (
                                                  named: Dict<Reference>,
                                                  positional: Reference[]
                                                  ) => CapturedArguments;

                                                    function curry

                                                    curry: <T extends CurriedType>(
                                                    type: T,
                                                    spec: object | string | CurriedValue<T>,
                                                    owner: Owner,
                                                    args: CapturedArguments | null,
                                                    resolved?: boolean
                                                    ) => CurriedValue<T>;

                                                      function dynamicAttribute

                                                      dynamicAttribute: (
                                                      element: SimpleElement,
                                                      attr: string,
                                                      namespace: Nullable<AttrNamespace>,
                                                      isTrusting?: boolean
                                                      ) => DynamicAttribute;

                                                        function inTransaction

                                                        inTransaction: (env: Environment, block: () => void) => void;

                                                          function invokeHelper

                                                          invokeHelper: (
                                                          context: object,
                                                          definition: object,
                                                          computeArgs?: (context: object) => Arguments
                                                          ) => Cache<unknown>;

                                                            function isSerializationFirstNode

                                                            isSerializationFirstNode: (node: SimpleNode) => boolean;

                                                              function isWhitespace

                                                              isWhitespace: (string: string) => boolean;

                                                                function normalizeProperty

                                                                normalizeProperty: (
                                                                element: SimpleElement,
                                                                slotName: string
                                                                ) => { normalized: any; type: any };

                                                                  function rehydrationBuilder

                                                                  rehydrationBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

                                                                    function reifyArgs

                                                                    reifyArgs: (args: CapturedArguments) => {
                                                                    named: Dict<unknown>;
                                                                    positional: unknown[];
                                                                    };

                                                                      function reifyNamed

                                                                      reifyNamed: (named: CapturedNamedArguments) => Dict<unknown>;

                                                                        function reifyPositional

                                                                        reifyPositional: (positional: CapturedPositionalArguments) => unknown[];

                                                                          function renderComponent

                                                                          renderComponent: (
                                                                          runtime: RuntimeContext,
                                                                          treeBuilder: ElementBuilder,
                                                                          context: CompileTimeCompilationContext,
                                                                          owner: Owner,
                                                                          definition: ComponentDefinitionState,
                                                                          args?: Record<string, unknown>,
                                                                          dynamicScope?: DynamicScope
                                                                          ) => TemplateIterator;

                                                                            function renderMain

                                                                            renderMain: (
                                                                            runtime: RuntimeContext,
                                                                            context: CompileTimeCompilationContext,
                                                                            owner: Owner,
                                                                            self: Reference,
                                                                            treeBuilder: ElementBuilder,
                                                                            layout: CompilableProgram,
                                                                            dynamicScope?: DynamicScope
                                                                            ) => TemplateIterator;

                                                                              function renderSync

                                                                              renderSync: (env: Environment, iterator: TemplateIterator) => RenderResult;

                                                                                function resetDebuggerCallback

                                                                                resetDebuggerCallback: () => void;

                                                                                  function runtimeContext

                                                                                  runtimeContext: (
                                                                                  options: EnvironmentOptions,
                                                                                  delegate: EnvironmentDelegate,
                                                                                  artifacts: RuntimeArtifacts,
                                                                                  resolver: RuntimeResolver
                                                                                  ) => RuntimeContext;

                                                                                    function setDebuggerCallback

                                                                                    setDebuggerCallback: (cb: DebugCallback) => void;

                                                                                      function templateOnlyComponent

                                                                                      templateOnlyComponent: (
                                                                                      moduleName?: string,
                                                                                      name?: string
                                                                                      ) => TemplateOnlyComponentDefinition;
                                                                                      • This utility function is used to declare a given component has no backing class. When the rendering engine detects this it is able to perform a number of optimizations. Templates that are associated with templateOnly() will be rendered _as is_ without adding a wrapping <div> (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)). Specifically, this means that the template will be rendered as "outer HTML".

                                                                                        In general, this method will be used by build time tooling and would not be directly written in an application. However, at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the template-only-glimmer-components optional feature.

                                                                                        Parameter moduleName

                                                                                        the module name that the template only component represents, this will be used for debugging purposes EMBER_GLIMMER_SET_COMPONENT_TEMPLATE

                                                                                        Example 1

                                                                                        ```js import { templateOnlyComponent } from '@glimmer/runtime';

                                                                                        export default templateOnlyComponent(); ```

                                                                                        templateOnly

                                                                                        Modifiers

                                                                                        • @public

                                                                                      Classes

                                                                                      class ConcreteBounds

                                                                                      class ConcreteBounds implements Bounds {}

                                                                                        constructor

                                                                                        constructor(parentNode: SimpleElement, first: SimpleNode, last: SimpleNode);

                                                                                          property parentNode

                                                                                          parentNode: SimpleElement;

                                                                                            method firstNode

                                                                                            firstNode: () => SimpleNode;

                                                                                              method lastNode

                                                                                              lastNode: () => SimpleNode;

                                                                                                method parentElement

                                                                                                parentElement: () => SimpleElement;

                                                                                                  class CurriedValue

                                                                                                  class CurriedValue<T extends CurriedType = CurriedType> {}

                                                                                                    property [ARGS]

                                                                                                    [ARGS]: any;

                                                                                                      property [INNER]

                                                                                                      [INNER]: string | object | CurriedValue<T>;

                                                                                                        property [OWNER]

                                                                                                        [OWNER]: Owner;

                                                                                                          property [RESOLVED]

                                                                                                          [RESOLVED]: boolean;

                                                                                                            property [TYPE]

                                                                                                            [TYPE]: CurriedType;

                                                                                                              class CursorImpl

                                                                                                              class CursorImpl implements Cursor {}

                                                                                                                constructor

                                                                                                                constructor(element: SimpleElement, nextSibling: Nullable<SimpleNode>);

                                                                                                                  property element

                                                                                                                  element: SimpleElement;

                                                                                                                    property nextSibling

                                                                                                                    nextSibling: Nullable<SimpleNode>;

                                                                                                                      class DynamicAttribute

                                                                                                                      abstract class DynamicAttribute implements AttributeOperation {}

                                                                                                                        constructor

                                                                                                                        constructor(attribute: AttributeCursor);

                                                                                                                          property attribute

                                                                                                                          attribute: AttributeCursor;

                                                                                                                            method set

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

                                                                                                                              method update

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

                                                                                                                                class DynamicScopeImpl

                                                                                                                                class DynamicScopeImpl implements DynamicScope {}

                                                                                                                                  constructor

                                                                                                                                  constructor(bucket?: Dict<Reference>);

                                                                                                                                    method child

                                                                                                                                    child: () => DynamicScopeImpl;

                                                                                                                                      method get

                                                                                                                                      get: (key: string) => Reference;

                                                                                                                                        method set

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

                                                                                                                                          class EnvironmentImpl

                                                                                                                                          class EnvironmentImpl implements Environment {}

                                                                                                                                            constructor

                                                                                                                                            constructor(options: EnvironmentOptions, delegate: EnvironmentDelegate);

                                                                                                                                              property [TRANSACTION]

                                                                                                                                              [TRANSACTION]: Nullable<TransactionImpl>;

                                                                                                                                                property appendOperations

                                                                                                                                                protected appendOperations: GlimmerTreeConstruction;

                                                                                                                                                  property debugRenderTree

                                                                                                                                                  debugRenderTree: DebugRenderTreeImpl<object>;

                                                                                                                                                    property isInteractive

                                                                                                                                                    isInteractive: boolean;

                                                                                                                                                      property updateOperations

                                                                                                                                                      protected updateOperations?: any;

                                                                                                                                                        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;

                                                                                                                                                                        class IDOMChanges

                                                                                                                                                                        class DOMChangesImpl extends DOMOperations implements GlimmerTreeChanges {}

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor(document: SimpleDocument);

                                                                                                                                                                            property document

                                                                                                                                                                            protected document: SimpleDocument;

                                                                                                                                                                              property namespace

                                                                                                                                                                              protected namespace: Nullable<string>;

                                                                                                                                                                                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;

                                                                                                                                                                                      class LowLevelVM

                                                                                                                                                                                      class VM implements PublicVM, InternalVM {}

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(
                                                                                                                                                                                        runtime: RuntimeContext,
                                                                                                                                                                                        { pc, scope, dynamicScope, stack }: VMState,
                                                                                                                                                                                        elementStack: ElementBuilder,
                                                                                                                                                                                        context: CompileTimeCompilationContext
                                                                                                                                                                                        );
                                                                                                                                                                                        • End of migrated.

                                                                                                                                                                                        property [ARGS$0]

                                                                                                                                                                                        readonly [ARGS$0]: VMArgumentsImpl;

                                                                                                                                                                                          property [CONSTANTS]

                                                                                                                                                                                          readonly [CONSTANTS]: any;

                                                                                                                                                                                            property [INNER_VM]

                                                                                                                                                                                            readonly [INNER_VM]: LowLevelVM;

                                                                                                                                                                                              property context

                                                                                                                                                                                              readonly context: CompileTimeCompilationContext;

                                                                                                                                                                                                property env

                                                                                                                                                                                                readonly env: Environment;

                                                                                                                                                                                                  property pc

                                                                                                                                                                                                  readonly pc: number;

                                                                                                                                                                                                    property program

                                                                                                                                                                                                    readonly program: RuntimeProgram;

                                                                                                                                                                                                      property runtime

                                                                                                                                                                                                      readonly runtime: RuntimeContext;

                                                                                                                                                                                                        property s0

                                                                                                                                                                                                        s0: {};

                                                                                                                                                                                                          property s1

                                                                                                                                                                                                          s1: {};

                                                                                                                                                                                                            property stack

                                                                                                                                                                                                            readonly stack: EvaluationStack;

                                                                                                                                                                                                              property t0

                                                                                                                                                                                                              t0: {};

                                                                                                                                                                                                                property t1

                                                                                                                                                                                                                t1: {};

                                                                                                                                                                                                                  property v0

                                                                                                                                                                                                                  v0: {};

                                                                                                                                                                                                                    method associateDestroyable

                                                                                                                                                                                                                    associateDestroyable: (child: Destroyable) => void;

                                                                                                                                                                                                                      method beginCacheGroup

                                                                                                                                                                                                                      beginCacheGroup: (name?: string) => void;

                                                                                                                                                                                                                        method bindDynamicScope

                                                                                                                                                                                                                        bindDynamicScope: (names: string[]) => void;

                                                                                                                                                                                                                          method call

                                                                                                                                                                                                                          call: (handle: number) => void;

                                                                                                                                                                                                                            method capture

                                                                                                                                                                                                                            capture: (args: number, pc?: number) => ResumableVMState;

                                                                                                                                                                                                                              method captureState

                                                                                                                                                                                                                              captureState: (args: number, pc?: number) => VMState;

                                                                                                                                                                                                                                method commitCacheGroup

                                                                                                                                                                                                                                commitCacheGroup: () => void;

                                                                                                                                                                                                                                  method compile

                                                                                                                                                                                                                                  compile: (block: CompilableTemplate) => number;

                                                                                                                                                                                                                                    method dynamicScope

                                                                                                                                                                                                                                    dynamicScope: () => DynamicScope;

                                                                                                                                                                                                                                      method elements

                                                                                                                                                                                                                                      elements: () => ElementBuilder;

                                                                                                                                                                                                                                        method empty

                                                                                                                                                                                                                                        static empty: (
                                                                                                                                                                                                                                        runtime: RuntimeContext,
                                                                                                                                                                                                                                        { handle, treeBuilder, dynamicScope, owner }: MinimalInitOptions,
                                                                                                                                                                                                                                        context: CompileTimeCompilationContext
                                                                                                                                                                                                                                        ) => InternalVM;

                                                                                                                                                                                                                                          method enter

                                                                                                                                                                                                                                          enter: (args: number) => void;

                                                                                                                                                                                                                                            method enterItem

                                                                                                                                                                                                                                            enterItem: ({ key, value, memo }: OpaqueIterationItem) => ListItemOpcode;

                                                                                                                                                                                                                                              method enterList

                                                                                                                                                                                                                                              enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

                                                                                                                                                                                                                                                method execute

                                                                                                                                                                                                                                                execute: (initialize?: (vm: this) => void) => RenderResult;

                                                                                                                                                                                                                                                  method exit

                                                                                                                                                                                                                                                  exit: () => void;

                                                                                                                                                                                                                                                    method exitList

                                                                                                                                                                                                                                                    exitList: () => void;

                                                                                                                                                                                                                                                      method fetch

                                                                                                                                                                                                                                                      fetch: (register: SyscallRegister) => void;

                                                                                                                                                                                                                                                        method fetchValue

                                                                                                                                                                                                                                                        fetchValue: { (register: MachineRegister): number; <T>(register: Register): T };

                                                                                                                                                                                                                                                          method getOwner

                                                                                                                                                                                                                                                          getOwner: () => Owner;

                                                                                                                                                                                                                                                            method getSelf

                                                                                                                                                                                                                                                            getSelf: () => Reference<any>;

                                                                                                                                                                                                                                                              method goto

                                                                                                                                                                                                                                                              goto: (offset: number) => void;

                                                                                                                                                                                                                                                                method initial

                                                                                                                                                                                                                                                                static initial: (
                                                                                                                                                                                                                                                                runtime: RuntimeContext,
                                                                                                                                                                                                                                                                context: CompileTimeCompilationContext,
                                                                                                                                                                                                                                                                { handle, self, dynamicScope, treeBuilder, numSymbols, owner }: InitOptions
                                                                                                                                                                                                                                                                ) => InternalVM;

                                                                                                                                                                                                                                                                  method listBlock

                                                                                                                                                                                                                                                                  listBlock: () => ListBlockOpcode;

                                                                                                                                                                                                                                                                    method load

                                                                                                                                                                                                                                                                    load: (register: SyscallRegister) => void;

                                                                                                                                                                                                                                                                      method loadValue

                                                                                                                                                                                                                                                                      loadValue: <T>(register: Register | MachineRegister, value: T) => void;

                                                                                                                                                                                                                                                                        method next

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

                                                                                                                                                                                                                                                                          method popDynamicScope

                                                                                                                                                                                                                                                                          popDynamicScope: () => void;

                                                                                                                                                                                                                                                                            method popFrame

                                                                                                                                                                                                                                                                            popFrame: () => void;

                                                                                                                                                                                                                                                                              method popScope

                                                                                                                                                                                                                                                                              popScope: () => void;

                                                                                                                                                                                                                                                                                method popUpdating

                                                                                                                                                                                                                                                                                popUpdating: () => UpdatingOpcode[];

                                                                                                                                                                                                                                                                                  method pushChildScope

                                                                                                                                                                                                                                                                                  pushChildScope: () => void;

                                                                                                                                                                                                                                                                                    method pushDynamicScope

                                                                                                                                                                                                                                                                                    pushDynamicScope: () => DynamicScope;

                                                                                                                                                                                                                                                                                      method pushFrame

                                                                                                                                                                                                                                                                                      pushFrame: () => void;
                                                                                                                                                                                                                                                                                      • Migrated to Inner

                                                                                                                                                                                                                                                                                      method pushRootScope

                                                                                                                                                                                                                                                                                      pushRootScope: (size: number, owner: Owner) => PartialScope;

                                                                                                                                                                                                                                                                                        method pushScope

                                                                                                                                                                                                                                                                                        pushScope: (scope: Scope) => void;

                                                                                                                                                                                                                                                                                          method pushUpdating

                                                                                                                                                                                                                                                                                          pushUpdating: (list?: UpdatingOpcode[]) => void;

                                                                                                                                                                                                                                                                                            method referenceForSymbol

                                                                                                                                                                                                                                                                                            referenceForSymbol: (symbol: number) => Reference;

                                                                                                                                                                                                                                                                                              method registerItem

                                                                                                                                                                                                                                                                                              registerItem: (opcode: ListItemOpcode) => void;

                                                                                                                                                                                                                                                                                                method return

                                                                                                                                                                                                                                                                                                return: () => void;

                                                                                                                                                                                                                                                                                                  method returnTo

                                                                                                                                                                                                                                                                                                  returnTo: (offset: number) => void;

                                                                                                                                                                                                                                                                                                    method scope

                                                                                                                                                                                                                                                                                                    scope: () => Scope;

                                                                                                                                                                                                                                                                                                      method tryUpdating

                                                                                                                                                                                                                                                                                                      tryUpdating: () => Nullable<UpdatingOpcode[]>;

                                                                                                                                                                                                                                                                                                        method updateWith

                                                                                                                                                                                                                                                                                                        updateWith: (opcode: UpdatingOpcode) => void;

                                                                                                                                                                                                                                                                                                          method updating

                                                                                                                                                                                                                                                                                                          updating: () => UpdatingOpcode[];

                                                                                                                                                                                                                                                                                                            class NewElementBuilder

                                                                                                                                                                                                                                                                                                            class NewElementBuilder implements ElementBuilder {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                              env: Environment,
                                                                                                                                                                                                                                                                                                              parentNode: SimpleElement,
                                                                                                                                                                                                                                                                                                              nextSibling: Nullable<SimpleNode>
                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                property [CURSOR_STACK]

                                                                                                                                                                                                                                                                                                                [CURSOR_STACK]: Stack$0<Cursor>;

                                                                                                                                                                                                                                                                                                                  property constructing

                                                                                                                                                                                                                                                                                                                  constructing: Nullable<SimpleElement>;

                                                                                                                                                                                                                                                                                                                    property dom

                                                                                                                                                                                                                                                                                                                    dom: GlimmerTreeConstruction;

                                                                                                                                                                                                                                                                                                                      property element

                                                                                                                                                                                                                                                                                                                      readonly element: SimpleElement;

                                                                                                                                                                                                                                                                                                                        property hasBlocks

                                                                                                                                                                                                                                                                                                                        readonly hasBlocks: boolean;

                                                                                                                                                                                                                                                                                                                          property nextSibling

                                                                                                                                                                                                                                                                                                                          readonly nextSibling: Nullable<SimpleNode>;

                                                                                                                                                                                                                                                                                                                            property operations

                                                                                                                                                                                                                                                                                                                            operations: Nullable<ElementOperations>;

                                                                                                                                                                                                                                                                                                                              property updateOperations

                                                                                                                                                                                                                                                                                                                              updateOperations: GlimmerTreeChanges;

                                                                                                                                                                                                                                                                                                                                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 block

                                                                                                                                                                                                                                                                                                                                            protected block: () => LiveBlock;

                                                                                                                                                                                                                                                                                                                                              method closeElement

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

                                                                                                                                                                                                                                                                                                                                                method debugBlocks

                                                                                                                                                                                                                                                                                                                                                debugBlocks: () => LiveBlock[];

                                                                                                                                                                                                                                                                                                                                                  method didAppendBounds

                                                                                                                                                                                                                                                                                                                                                  didAppendBounds: (bounds: Bounds) => Bounds;

                                                                                                                                                                                                                                                                                                                                                    method didAppendNode

                                                                                                                                                                                                                                                                                                                                                    didAppendNode: <T extends SimpleNode>(node: T) => T;

                                                                                                                                                                                                                                                                                                                                                      method didOpenElement

                                                                                                                                                                                                                                                                                                                                                      didOpenElement: (element: SimpleElement) => SimpleElement;

                                                                                                                                                                                                                                                                                                                                                        method flushElement

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

                                                                                                                                                                                                                                                                                                                                                          method forInitialRender

                                                                                                                                                                                                                                                                                                                                                          static forInitialRender: (
                                                                                                                                                                                                                                                                                                                                                          env: Environment,
                                                                                                                                                                                                                                                                                                                                                          cursor: CursorImpl
                                                                                                                                                                                                                                                                                                                                                          ) => NewElementBuilder;

                                                                                                                                                                                                                                                                                                                                                            method initialize

                                                                                                                                                                                                                                                                                                                                                            protected initialize: () => this;

                                                                                                                                                                                                                                                                                                                                                              method openElement

                                                                                                                                                                                                                                                                                                                                                              openElement: (tag: string) => SimpleElement;

                                                                                                                                                                                                                                                                                                                                                                method popBlock

                                                                                                                                                                                                                                                                                                                                                                popBlock: () => LiveBlock;

                                                                                                                                                                                                                                                                                                                                                                  method popElement

                                                                                                                                                                                                                                                                                                                                                                  popElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                    method popRemoteElement

                                                                                                                                                                                                                                                                                                                                                                    popRemoteElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                      method pushBlockList

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

                                                                                                                                                                                                                                                                                                                                                                        method pushElement

                                                                                                                                                                                                                                                                                                                                                                        protected pushElement: (
                                                                                                                                                                                                                                                                                                                                                                        element: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                        nextSibling?: Maybe<SimpleNode>
                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                          method pushLiveBlock

                                                                                                                                                                                                                                                                                                                                                                          protected pushLiveBlock: <T extends LiveBlock>(
                                                                                                                                                                                                                                                                                                                                                                          block: T,
                                                                                                                                                                                                                                                                                                                                                                          isRemote?: boolean
                                                                                                                                                                                                                                                                                                                                                                          ) => T;

                                                                                                                                                                                                                                                                                                                                                                            method pushRemoteElement

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

                                                                                                                                                                                                                                                                                                                                                                              method pushSimpleBlock

                                                                                                                                                                                                                                                                                                                                                                              pushSimpleBlock: () => LiveBlock;

                                                                                                                                                                                                                                                                                                                                                                                method pushUpdatableBlock

                                                                                                                                                                                                                                                                                                                                                                                pushUpdatableBlock: () => UpdatableBlockImpl;

                                                                                                                                                                                                                                                                                                                                                                                  method resume

                                                                                                                                                                                                                                                                                                                                                                                  static resume: (env: Environment, block: UpdatableBlock) => NewElementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                    method setDynamicAttribute

                                                                                                                                                                                                                                                                                                                                                                                    setDynamicAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                                    value: unknown,
                                                                                                                                                                                                                                                                                                                                                                                    trusting: boolean,
                                                                                                                                                                                                                                                                                                                                                                                    namespace: Nullable<AttrNamespace>
                                                                                                                                                                                                                                                                                                                                                                                    ) => DynamicAttribute;

                                                                                                                                                                                                                                                                                                                                                                                      method setStaticAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                        method willCloseElement

                                                                                                                                                                                                                                                                                                                                                                                        willCloseElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                          class PartialScopeImpl

                                                                                                                                                                                                                                                                                                                                                                                          class PartialScopeImpl implements PartialScope {}

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                            slots: ScopeSlot[],
                                                                                                                                                                                                                                                                                                                                                                                            owner: Owner,
                                                                                                                                                                                                                                                                                                                                                                                            callerScope: any,
                                                                                                                                                                                                                                                                                                                                                                                            evalScope: any,
                                                                                                                                                                                                                                                                                                                                                                                            partialMap: any
                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                              property owner

                                                                                                                                                                                                                                                                                                                                                                                              readonly owner: Owner;

                                                                                                                                                                                                                                                                                                                                                                                                property slots

                                                                                                                                                                                                                                                                                                                                                                                                readonly slots: ScopeSlot[];

                                                                                                                                                                                                                                                                                                                                                                                                  method bind

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

                                                                                                                                                                                                                                                                                                                                                                                                    method bindBlock

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

                                                                                                                                                                                                                                                                                                                                                                                                      method bindCallerScope

                                                                                                                                                                                                                                                                                                                                                                                                      bindCallerScope: (scope: Nullable<Scope>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method bindEvalScope

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

                                                                                                                                                                                                                                                                                                                                                                                                          method bindPartialMap

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

                                                                                                                                                                                                                                                                                                                                                                                                            method bindSelf

                                                                                                                                                                                                                                                                                                                                                                                                            bindSelf: (self: Reference<unknown>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method bindSymbol

                                                                                                                                                                                                                                                                                                                                                                                                              bindSymbol: (symbol: number, value: Reference<unknown>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                method child

                                                                                                                                                                                                                                                                                                                                                                                                                child: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                  method getBlock

                                                                                                                                                                                                                                                                                                                                                                                                                  getBlock: (symbol: number) => Nullable<ScopeBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getCallerScope

                                                                                                                                                                                                                                                                                                                                                                                                                    getCallerScope: () => Nullable<Scope>;

                                                                                                                                                                                                                                                                                                                                                                                                                      method getEvalScope

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

                                                                                                                                                                                                                                                                                                                                                                                                                        method getPartialMap

                                                                                                                                                                                                                                                                                                                                                                                                                        getPartialMap: () => Nullable<Dict<Reference<unknown>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                          method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                          getSelf: () => Reference<unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                            method getSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                            getSymbol: (symbol: number) => Reference<unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                              method init

                                                                                                                                                                                                                                                                                                                                                                                                                              init: ({ self }: { self: Reference<unknown> }) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                method root

                                                                                                                                                                                                                                                                                                                                                                                                                                static root: (
                                                                                                                                                                                                                                                                                                                                                                                                                                self: Reference<unknown>,
                                                                                                                                                                                                                                                                                                                                                                                                                                size: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                owner: Owner
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => PartialScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method sized

                                                                                                                                                                                                                                                                                                                                                                                                                                  static sized: (size: number, owner: Owner) => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                    class RehydrateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                    class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                      env: Environment,
                                                                                                                                                                                                                                                                                                                                                                                                                                      parentNode: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                      nextSibling: Nullable<SimpleNode>
                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                        property [CURSOR_STACK]

                                                                                                                                                                                                                                                                                                                                                                                                                                        [CURSOR_STACK]: Stack$0<RehydratingCursor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property blockDepth

                                                                                                                                                                                                                                                                                                                                                                                                                                          blockDepth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property candidate

                                                                                                                                                                                                                                                                                                                                                                                                                                            candidate: Nullable<SimpleNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property currentCursor

                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly currentCursor: Nullable<RehydratingCursor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property startingBlockOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                startingBlockOffset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method didAppendBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                  didAppendBounds: (bounds: Bounds) => Bounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method disableRehydration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    disableRehydration: (nextSibling: Nullable<SimpleNode>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method enableRehydration

                                                                                                                                                                                                                                                                                                                                                                                                                                                      enableRehydration: (candidate: Nullable<SimpleNode>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getMarker: (element: HTMLElement, guid: string) => Nullable<SimpleNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pushElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                          pushElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          this:
                                                                                                                                                                                                                                                                                                                                                                                                                                                          | RehydrateBuilder
                                                                                                                                                                                                                                                                                                                                                                                                                                                          | (NewElementBuilder &
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<Pick<RehydrateBuilder, 'blockDepth' | 'candidate'>>),
                                                                                                                                                                                                                                                                                                                                                                                                                                                          element: SimpleElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          nextSibling?: Maybe<SimpleNode>
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected remove: (node: SimpleNode) => Nullable<SimpleNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method willCloseElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                              willCloseElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class RemoteLiveBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class RemoteLiveBlock extends SimpleLiveBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(parent: SimpleElement);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SimpleDynamicAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SimpleDynamicAttribute extends DynamicAttribute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method set

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TemplateOnlyComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TemplateOnlyComponentDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(moduleName?: string, name?: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              moduleName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TemplateOnlyComponentManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TemplateOnlyComponentManager implements InternalComponentManager {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getCapabilities: () => InternalComponentCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDebugName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDebugName: ({ name }: TemplateOnlyComponentDefinition) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDestroyable: () => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getSelf: () => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class UpdatableBlockImpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reset: () => Nullable<SimpleNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class UpdatingVM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class UpdatingVM implements IUpdatingVM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    env: Environment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { alwaysRevalidate }: { alwaysRevalidate?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnvironmentDelegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EnvironmentDelegate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enableDebugTooling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enableDebugTooling: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Used to enable debug tooling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isInteractive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isInteractive: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Used to determine the the environment is interactive (e.g. SSR is not interactive). Interactive environments schedule modifiers, among other things.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onTransactionCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onTransactionCommit: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Callback to be called when an environment transaction commits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InternalVM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InternalVM {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • This interface is used by internal opcodes, and is more stable than the implementation of the Append VM itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property [ARGS$0]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly [ARGS$0]: VMArgumentsImpl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property [CONSTANTS]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly context: CompileTimeCompilationContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly env: Environment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property runtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly runtime: RuntimeContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly stack: EvaluationStack;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method associateDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  associateDestroyable: (d: Destroyable) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method beginCacheGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    beginCacheGroup: (name?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method bindDynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bindDynamicScope: (names: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call: (handle: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method commitCacheGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          commitCacheGroup: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method compile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            compile: (block: CompilableTemplate) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method dynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dynamicScope: () => DynamicScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                elements: () => ElementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method enter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enter: (args: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method enterItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enterItem: (item: OpaqueIterationItem) => ListItemOpcode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method enterList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method execute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        execute: (initialize?: (vm: this) => void) => RenderResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method exit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          exit: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method exitList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exitList: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fetch: (register: Register) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fetchValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fetchValue: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (register: MachineRegister.ra | MachineRegister.pc): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <T>(register: Register): T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (register: Register): unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getOwner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getOwner: () => Owner;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getSelf: () => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method goto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      goto: (pc: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        load: (register: Register) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method loadValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          loadValue: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (register: MachineRegister, value: number): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (register: Register, value: unknown): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (register: any, value: unknown): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method next

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method popDynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              popDynamicScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method popScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                popScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method pushChildScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pushChildScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pushDynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pushDynamicScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method pushFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pushFrame: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pushRootScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pushRootScope: (size: number, owner: Owner) => PartialScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pushScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pushScope: (scope: Scope) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method pushUpdating

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pushUpdating: (list?: UpdatingOpcode[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method referenceForSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              referenceForSymbol: (symbol: number) => Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method registerItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerItem: (item: ListItemOpcode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scope: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method updateWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    updateWith: (opcode: UpdatingOpcode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SafeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SafeString {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toHTML: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DebugCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DebugCallback = (context: unknown, get: DebugGet) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DOMTreeConstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DOMTreeConstruction = TreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IteratorResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IteratorResult<T> = RichIteratorResult<null, T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (9)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@glimmer/runtime.

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