@glimmer/runtime

  • Version 0.81.0
  • Published
  • 4.32 MB
  • 13 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 array

const array: {};

    variable concat

    const concat: {};

      variable DOMChanges

      let DOMChanges: typeof DOMChangesImpl;

        variable DOMTreeConstruction

        const DOMTreeConstruction: typeof DOM.TreeConstruction;

          variable EMPTY_ARGS

          const EMPTY_ARGS: any;

            variable EMPTY_NAMED

            const EMPTY_NAMED: any;

              variable EMPTY_POSITIONAL

              const EMPTY_POSITIONAL: any;

                variable fn

                const fn: {};

                  variable get

                  const get: {};

                    variable hash

                    const hash: {};

                      variable on

                      const on: {};

                        variable SERIALIZATION_FIRST_NODE_STRING

                        const SERIALIZATION_FIRST_NODE_STRING: string;

                          variable TEMPLATE_ONLY_COMPONENT_MANAGER

                          const TEMPLATE_ONLY_COMPONENT_MANAGER: TemplateOnlyComponentManager;

                            Functions

                            function clear

                            clear: (bounds: any) => any;

                              function clientBuilder

                              clientBuilder: (env: any, cursor: CursorImpl) => any;

                                function createCapturedArgs

                                createCapturedArgs: (named: any, positional: Reference[]) => any;

                                  function curry

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

                                    function dynamicAttribute

                                    dynamicAttribute: (
                                    element: any,
                                    attr: string,
                                    namespace: any,
                                    isTrusting?: boolean
                                    ) => DynamicAttribute;

                                      function inTransaction

                                      inTransaction: (env: any, cb: () => void) => void;

                                        function invokeHelper

                                        invokeHelper: (
                                        context: object,
                                        definition: object,
                                        computeArgs?: (context: object) => any
                                        ) => any;

                                          function isSerializationFirstNode

                                          isSerializationFirstNode: (node: any) => boolean;

                                            function isWhitespace

                                            isWhitespace: (string: string) => boolean;

                                              function normalizeProperty

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

                                                function rehydrationBuilder

                                                rehydrationBuilder: (env: any, cursor: CursorImpl) => any;

                                                  function reifyArgs

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

                                                    function reifyNamed

                                                    reifyNamed: (named: any) => any;

                                                      function reifyPositional

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

                                                        function renderComponent

                                                        renderComponent: (
                                                        runtime: any,
                                                        treeBuilder: any,
                                                        context: any,
                                                        owner: any,
                                                        definition: any,
                                                        args?: Record<string, unknown>,
                                                        dynamicScope?: any
                                                        ) => any;

                                                          function renderMain

                                                          renderMain: (
                                                          runtime: any,
                                                          context: any,
                                                          owner: any,
                                                          self: any,
                                                          treeBuilder: any,
                                                          layout: any,
                                                          dynamicScope?: any
                                                          ) => any;

                                                            function renderSync

                                                            renderSync: (env: any, iterator: any) => any;

                                                              function resetDebuggerCallback

                                                              resetDebuggerCallback: () => void;

                                                                function runtimeContext

                                                                runtimeContext: (
                                                                options: any,
                                                                delegate: EnvironmentDelegate,
                                                                artifacts: any,
                                                                resolver: any
                                                                ) => any;

                                                                  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: any, first: any, last: any);

                                                                        property parentNode

                                                                        parentNode: any;

                                                                          method firstNode

                                                                          firstNode: () => any;

                                                                            method lastNode

                                                                            lastNode: () => any;

                                                                              method parentElement

                                                                              parentElement: () => any;

                                                                                class CurriedValue

                                                                                class CurriedValue<T extends CurriedType = CurriedType> {}

                                                                                  property [ARGS]

                                                                                  [ARGS]: any;

                                                                                    property [INNER]

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

                                                                                      property [OWNER]

                                                                                      [OWNER]: any;

                                                                                        property [RESOLVED]

                                                                                        [RESOLVED]: boolean;

                                                                                          property [TYPE]

                                                                                          [TYPE]: any;

                                                                                            class CursorImpl

                                                                                            class CursorImpl implements Cursor {}

                                                                                              constructor

                                                                                              constructor(element: any, nextSibling: any);

                                                                                                property element

                                                                                                element: any;

                                                                                                  property nextSibling

                                                                                                  nextSibling: any;

                                                                                                    class DynamicAttribute

                                                                                                    abstract class DynamicAttribute implements AttributeOperation {}

                                                                                                      constructor

                                                                                                      constructor(attribute: any);

                                                                                                        property attribute

                                                                                                        attribute: any;

                                                                                                          method set

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

                                                                                                            method update

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

                                                                                                              class DynamicScopeImpl

                                                                                                              class DynamicScopeImpl implements DynamicScope {}

                                                                                                                constructor

                                                                                                                constructor(bucket?: any);

                                                                                                                  method child

                                                                                                                  child: () => DynamicScopeImpl;

                                                                                                                    method get

                                                                                                                    get: (key: string) => any;

                                                                                                                      method set

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

                                                                                                                        class EnvironmentImpl

                                                                                                                        class EnvironmentImpl implements Environment {}

                                                                                                                          constructor

                                                                                                                          constructor(options: any, delegate: EnvironmentDelegate);

                                                                                                                            property [TRANSACTION]

                                                                                                                            [TRANSACTION]: any;

                                                                                                                              property appendOperations

                                                                                                                              protected appendOperations: any;

                                                                                                                                property debugRenderTree

                                                                                                                                debugRenderTree: DebugRenderTree<object>;

                                                                                                                                  property isInteractive

                                                                                                                                  isInteractive: boolean;

                                                                                                                                    property updateOperations

                                                                                                                                    protected updateOperations?: any;

                                                                                                                                      method begin

                                                                                                                                      begin: () => void;

                                                                                                                                        method commit

                                                                                                                                        commit: () => void;

                                                                                                                                          method didCreate

                                                                                                                                          didCreate: (component: any) => void;

                                                                                                                                            method didUpdate

                                                                                                                                            didUpdate: (component: any) => void;

                                                                                                                                              method getAppendOperations

                                                                                                                                              getAppendOperations: () => any;

                                                                                                                                                method getDOM

                                                                                                                                                getDOM: () => any;

                                                                                                                                                  method scheduleInstallModifier

                                                                                                                                                  scheduleInstallModifier: (modifier: any) => void;

                                                                                                                                                    method scheduleUpdateModifier

                                                                                                                                                    scheduleUpdateModifier: (modifier: any) => void;

                                                                                                                                                      class IDOMChanges

                                                                                                                                                      class DOMChangesImpl extends DOMOperations implements GlimmerTreeChanges {}

                                                                                                                                                        constructor

                                                                                                                                                        constructor(document: any);

                                                                                                                                                          property document

                                                                                                                                                          protected document: any;

                                                                                                                                                            property namespace

                                                                                                                                                            protected namespace: any;

                                                                                                                                                              method insertAfter

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

                                                                                                                                                                method removeAttribute

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

                                                                                                                                                                  method setAttribute

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

                                                                                                                                                                    class LowLevelVM

                                                                                                                                                                    class VM implements PublicVM, InternalVM {}

                                                                                                                                                                      constructor

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

                                                                                                                                                                      property [ARGS]

                                                                                                                                                                      readonly [ARGS]: VMArgumentsImpl;

                                                                                                                                                                        property [CONSTANTS]

                                                                                                                                                                        readonly [CONSTANTS]: any;

                                                                                                                                                                          property [INNER_VM]

                                                                                                                                                                          readonly [INNER_VM]: LowLevelVM;

                                                                                                                                                                            property context

                                                                                                                                                                            readonly context: any;

                                                                                                                                                                              property env

                                                                                                                                                                              readonly env: any;

                                                                                                                                                                                property pc

                                                                                                                                                                                readonly pc: number;

                                                                                                                                                                                  property program

                                                                                                                                                                                  readonly program: any;

                                                                                                                                                                                    property runtime

                                                                                                                                                                                    readonly runtime: any;

                                                                                                                                                                                      property s0

                                                                                                                                                                                      s0: {};

                                                                                                                                                                                        property s1

                                                                                                                                                                                        s1: {};

                                                                                                                                                                                          property stack

                                                                                                                                                                                          readonly stack: EvaluationStack;

                                                                                                                                                                                            property t0

                                                                                                                                                                                            t0: {};

                                                                                                                                                                                              property t1

                                                                                                                                                                                              t1: {};

                                                                                                                                                                                                property v0

                                                                                                                                                                                                v0: {};

                                                                                                                                                                                                  method associateDestroyable

                                                                                                                                                                                                  associateDestroyable: (child: any) => 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: any) => number;

                                                                                                                                                                                                                  method dynamicScope

                                                                                                                                                                                                                  dynamicScope: () => any;

                                                                                                                                                                                                                    method elements

                                                                                                                                                                                                                    elements: () => any;

                                                                                                                                                                                                                      method empty

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

                                                                                                                                                                                                                        method enter

                                                                                                                                                                                                                        enter: (args: number) => void;

                                                                                                                                                                                                                          method enterItem

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

                                                                                                                                                                                                                            method enterList

                                                                                                                                                                                                                            enterList: (iterableRef: any, offset: number) => void;

                                                                                                                                                                                                                              method execute

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

                                                                                                                                                                                                                                method exit

                                                                                                                                                                                                                                exit: () => void;

                                                                                                                                                                                                                                  method exitList

                                                                                                                                                                                                                                  exitList: () => void;

                                                                                                                                                                                                                                    method fetch

                                                                                                                                                                                                                                    fetch: (register: any) => void;

                                                                                                                                                                                                                                      method fetchValue

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

                                                                                                                                                                                                                                        method getOwner

                                                                                                                                                                                                                                        getOwner: () => any;

                                                                                                                                                                                                                                          method getSelf

                                                                                                                                                                                                                                          getSelf: () => any;

                                                                                                                                                                                                                                            method goto

                                                                                                                                                                                                                                            goto: (offset: number) => void;

                                                                                                                                                                                                                                              method initial

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

                                                                                                                                                                                                                                                method listBlock

                                                                                                                                                                                                                                                listBlock: () => ListBlockOpcode;

                                                                                                                                                                                                                                                  method load

                                                                                                                                                                                                                                                  load: (register: any) => void;

                                                                                                                                                                                                                                                    method loadValue

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

                                                                                                                                                                                                                                                      method next

                                                                                                                                                                                                                                                      next: () => any;

                                                                                                                                                                                                                                                        method popDynamicScope

                                                                                                                                                                                                                                                        popDynamicScope: () => void;

                                                                                                                                                                                                                                                          method popFrame

                                                                                                                                                                                                                                                          popFrame: () => void;

                                                                                                                                                                                                                                                            method popScope

                                                                                                                                                                                                                                                            popScope: () => void;

                                                                                                                                                                                                                                                              method popUpdating

                                                                                                                                                                                                                                                              popUpdating: () => UpdatingOpcode[];

                                                                                                                                                                                                                                                                method pushChildScope

                                                                                                                                                                                                                                                                pushChildScope: () => void;

                                                                                                                                                                                                                                                                  method pushDynamicScope

                                                                                                                                                                                                                                                                  pushDynamicScope: () => any;

                                                                                                                                                                                                                                                                    method pushFrame

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

                                                                                                                                                                                                                                                                    method pushRootScope

                                                                                                                                                                                                                                                                    pushRootScope: (size: number, owner: any) => any;

                                                                                                                                                                                                                                                                      method pushScope

                                                                                                                                                                                                                                                                      pushScope: (scope: any) => void;

                                                                                                                                                                                                                                                                        method pushUpdating

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

                                                                                                                                                                                                                                                                          method referenceForSymbol

                                                                                                                                                                                                                                                                          referenceForSymbol: (symbol: number) => any;

                                                                                                                                                                                                                                                                            method registerItem

                                                                                                                                                                                                                                                                            registerItem: (opcode: ListItemOpcode) => void;

                                                                                                                                                                                                                                                                              method return

                                                                                                                                                                                                                                                                              return: () => void;

                                                                                                                                                                                                                                                                                method returnTo

                                                                                                                                                                                                                                                                                returnTo: (offset: number) => void;

                                                                                                                                                                                                                                                                                  method scope

                                                                                                                                                                                                                                                                                  scope: () => any;

                                                                                                                                                                                                                                                                                    method tryUpdating

                                                                                                                                                                                                                                                                                    tryUpdating: () => any;

                                                                                                                                                                                                                                                                                      method updateWith

                                                                                                                                                                                                                                                                                      updateWith: (opcode: any) => void;

                                                                                                                                                                                                                                                                                        method updating

                                                                                                                                                                                                                                                                                        updating: () => UpdatingOpcode[];

                                                                                                                                                                                                                                                                                          class NewElementBuilder

                                                                                                                                                                                                                                                                                          class NewElementBuilder implements ElementBuilder {}

                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                            constructor(env: any, parentNode: any, nextSibling: any);

                                                                                                                                                                                                                                                                                              property [CURSOR_STACK]

                                                                                                                                                                                                                                                                                              [CURSOR_STACK]: any;

                                                                                                                                                                                                                                                                                                property constructing

                                                                                                                                                                                                                                                                                                constructing: any;

                                                                                                                                                                                                                                                                                                  property dom

                                                                                                                                                                                                                                                                                                  dom: any;

                                                                                                                                                                                                                                                                                                    property element

                                                                                                                                                                                                                                                                                                    readonly element: any;

                                                                                                                                                                                                                                                                                                      property hasBlocks

                                                                                                                                                                                                                                                                                                      readonly hasBlocks: boolean;

                                                                                                                                                                                                                                                                                                        property nextSibling

                                                                                                                                                                                                                                                                                                        readonly nextSibling: any;

                                                                                                                                                                                                                                                                                                          property operations

                                                                                                                                                                                                                                                                                                          operations: any;

                                                                                                                                                                                                                                                                                                            property updateOperations

                                                                                                                                                                                                                                                                                                            updateOperations: any;

                                                                                                                                                                                                                                                                                                              method appendComment

                                                                                                                                                                                                                                                                                                              appendComment: (string: string) => any;

                                                                                                                                                                                                                                                                                                                method appendDynamicFragment

                                                                                                                                                                                                                                                                                                                appendDynamicFragment: (value: any) => void;

                                                                                                                                                                                                                                                                                                                  method appendDynamicHTML

                                                                                                                                                                                                                                                                                                                  appendDynamicHTML: (value: string) => void;

                                                                                                                                                                                                                                                                                                                    method appendDynamicNode

                                                                                                                                                                                                                                                                                                                    appendDynamicNode: (value: any) => void;

                                                                                                                                                                                                                                                                                                                      method appendDynamicText

                                                                                                                                                                                                                                                                                                                      appendDynamicText: (value: string) => any;

                                                                                                                                                                                                                                                                                                                        method appendText

                                                                                                                                                                                                                                                                                                                        appendText: (string: string) => any;

                                                                                                                                                                                                                                                                                                                          method block

                                                                                                                                                                                                                                                                                                                          protected block: () => any;

                                                                                                                                                                                                                                                                                                                            method closeElement

                                                                                                                                                                                                                                                                                                                            closeElement: () => any;

                                                                                                                                                                                                                                                                                                                              method debugBlocks

                                                                                                                                                                                                                                                                                                                              debugBlocks: () => LiveBlock[];

                                                                                                                                                                                                                                                                                                                                method didAppendBounds

                                                                                                                                                                                                                                                                                                                                didAppendBounds: (bounds: any) => any;

                                                                                                                                                                                                                                                                                                                                  method didAppendNode

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

                                                                                                                                                                                                                                                                                                                                    method didOpenElement

                                                                                                                                                                                                                                                                                                                                    didOpenElement: (element: any) => any;

                                                                                                                                                                                                                                                                                                                                      method flushElement

                                                                                                                                                                                                                                                                                                                                      flushElement: (modifiers: any) => void;

                                                                                                                                                                                                                                                                                                                                        method forInitialRender

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

                                                                                                                                                                                                                                                                                                                                          method initialize

                                                                                                                                                                                                                                                                                                                                          protected initialize: () => this;

                                                                                                                                                                                                                                                                                                                                            method openElement

                                                                                                                                                                                                                                                                                                                                            openElement: (tag: string) => any;

                                                                                                                                                                                                                                                                                                                                              method popBlock

                                                                                                                                                                                                                                                                                                                                              popBlock: () => any;

                                                                                                                                                                                                                                                                                                                                                method popElement

                                                                                                                                                                                                                                                                                                                                                popElement: () => void;

                                                                                                                                                                                                                                                                                                                                                  method popRemoteElement

                                                                                                                                                                                                                                                                                                                                                  popRemoteElement: () => void;

                                                                                                                                                                                                                                                                                                                                                    method pushBlockList

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

                                                                                                                                                                                                                                                                                                                                                      method pushElement

                                                                                                                                                                                                                                                                                                                                                      protected pushElement: (element: any, nextSibling?: any) => void;

                                                                                                                                                                                                                                                                                                                                                        method pushLiveBlock

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

                                                                                                                                                                                                                                                                                                                                                          method pushRemoteElement

                                                                                                                                                                                                                                                                                                                                                          pushRemoteElement: (element: any, guid: string, insertBefore: any) => any;

                                                                                                                                                                                                                                                                                                                                                            method pushSimpleBlock

                                                                                                                                                                                                                                                                                                                                                            pushSimpleBlock: () => any;

                                                                                                                                                                                                                                                                                                                                                              method pushUpdatableBlock

                                                                                                                                                                                                                                                                                                                                                              pushUpdatableBlock: () => UpdatableBlockImpl;

                                                                                                                                                                                                                                                                                                                                                                method resume

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

                                                                                                                                                                                                                                                                                                                                                                  method setDynamicAttribute

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

                                                                                                                                                                                                                                                                                                                                                                    method setStaticAttribute

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

                                                                                                                                                                                                                                                                                                                                                                      method willCloseElement

                                                                                                                                                                                                                                                                                                                                                                      willCloseElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                        class PartialScopeImpl

                                                                                                                                                                                                                                                                                                                                                                        class PartialScopeImpl implements PartialScope {}

                                                                                                                                                                                                                                                                                                                                                                          constructor

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

                                                                                                                                                                                                                                                                                                                                                                            property owner

                                                                                                                                                                                                                                                                                                                                                                            readonly owner: any;

                                                                                                                                                                                                                                                                                                                                                                              property slots

                                                                                                                                                                                                                                                                                                                                                                              readonly slots: any[];

                                                                                                                                                                                                                                                                                                                                                                                method bind

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

                                                                                                                                                                                                                                                                                                                                                                                  method bindBlock

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

                                                                                                                                                                                                                                                                                                                                                                                    method bindCallerScope

                                                                                                                                                                                                                                                                                                                                                                                    bindCallerScope: (scope: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                      method bindEvalScope

                                                                                                                                                                                                                                                                                                                                                                                      bindEvalScope: (map: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method bindPartialMap

                                                                                                                                                                                                                                                                                                                                                                                        bindPartialMap: (map: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method bindSelf

                                                                                                                                                                                                                                                                                                                                                                                          bindSelf: (self: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                            method bindSymbol

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

                                                                                                                                                                                                                                                                                                                                                                                              method child

                                                                                                                                                                                                                                                                                                                                                                                              child: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                method getBlock

                                                                                                                                                                                                                                                                                                                                                                                                getBlock: (symbol: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                  method getCallerScope

                                                                                                                                                                                                                                                                                                                                                                                                  getCallerScope: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                    method getEvalScope

                                                                                                                                                                                                                                                                                                                                                                                                    getEvalScope: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                      method getPartialMap

                                                                                                                                                                                                                                                                                                                                                                                                      getPartialMap: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                        method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                        getSelf: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                          method getSymbol

                                                                                                                                                                                                                                                                                                                                                                                                          getSymbol: (symbol: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                            method init

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

                                                                                                                                                                                                                                                                                                                                                                                                              method root

                                                                                                                                                                                                                                                                                                                                                                                                              static root: (self: any, size: number | undefined, owner: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                method sized

                                                                                                                                                                                                                                                                                                                                                                                                                static sized: (size: number | undefined, owner: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                  class RehydrateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                  class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {}

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(env: any, parentNode: any, nextSibling: any);

                                                                                                                                                                                                                                                                                                                                                                                                                      property [CURSOR_STACK]

                                                                                                                                                                                                                                                                                                                                                                                                                      [CURSOR_STACK]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                        property blockDepth

                                                                                                                                                                                                                                                                                                                                                                                                                        blockDepth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                          property candidate

                                                                                                                                                                                                                                                                                                                                                                                                                          candidate: any;

                                                                                                                                                                                                                                                                                                                                                                                                                            property currentCursor

                                                                                                                                                                                                                                                                                                                                                                                                                            readonly currentCursor: any;

                                                                                                                                                                                                                                                                                                                                                                                                                              property startingBlockOffset

                                                                                                                                                                                                                                                                                                                                                                                                                              startingBlockOffset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                method didAppendBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                didAppendBounds: (bounds: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method disableRehydration

                                                                                                                                                                                                                                                                                                                                                                                                                                  disableRehydration: (nextSibling: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method enableRehydration

                                                                                                                                                                                                                                                                                                                                                                                                                                    enableRehydration: (candidate: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                      getMarker: (element: HTMLElement, guid: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method pushElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                          protected remove: (node: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method willCloseElement

                                                                                                                                                                                                                                                                                                                                                                                                                                            willCloseElement: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              class RemoteLiveBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                              class RemoteLiveBlock extends SimpleLiveBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(parent: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SimpleDynamicAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SimpleDynamicAttribute extends DynamicAttribute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method set

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                      update: (value: unknown, _env: any) => 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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDebugName

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDestroyable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDestroyable: () => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSelf: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class UpdatableBlockImpl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reset: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UpdatingVM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UpdatingVMImpl implements UpdatingVM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  env: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { alwaysRevalidate }: { alwaysRevalidate?: boolean | undefined }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property alwaysRevalidate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alwaysRevalidate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dom: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        env: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method execute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method goto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            goto: (index: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              throw: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method try

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                try: (ops: UpdatingOpcode[], handler: any) => 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]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly [ARGS]: 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: any) => 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: any) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method dynamicScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dynamicScope: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elements: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method enter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enter: (args: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method enterItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enterItem: (item: any) => ListItemOpcode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method enterList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enterList: (iterableRef: any, offset: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method execute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method exit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exit: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method exitList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          exitList: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fetch: (register: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method fetchValue

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getOwner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getOwner: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getSelf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getSelf: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method goto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    goto: (pc: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load: (register: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method loadValue

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          next: () => any;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pushScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pushScope: (scope: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pushUpdating

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method referenceForSymbol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            referenceForSymbol: (symbol: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method registerItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              registerItem: (item: ListItemOpcode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scope: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method updateWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateWith: (opcode: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SafeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SafeString {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toHTML: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DebugCallback

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DOMTreeConstruction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DOMTreeConstruction = DOM.DOMTreeConstruction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IteratorResult

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (24)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (13)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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>